@Override public Headers headers() { return this.delegate.headers(); }
@Override public Headers headers() { return delegate.headers(); }
public static ExchangeFilterFunction convertLegacyEndpoint(LegacyEndpointConverter converter) { return (ClientRequest request, ExchangeFunction next) -> { Mono<ClientResponse> clientResponse = next.exchange(request); if (request.attribute(ATTRIBUTE_ENDPOINT).map(converter::canConvert).orElse(false)) { return clientResponse.flatMap(response -> { if (response.headers() .contentType() .map(t -> ACTUATOR_V1_MEDIATYPE.isCompatibleWith(t) || APPLICATION_JSON.isCompatibleWith(t)) .orElse(false)) { return convertClientResponse(converter::convert, ACTUATOR_V2_MEDIATYPE).apply(response); } return Mono.just(response); }); } return clientResponse; }; }
@Test public void headers() { ClientResponse.Headers headers = mock(ClientResponse.Headers.class); when(mockResponse.headers()).thenReturn(headers); assertSame(headers, wrapper.headers()); }
.defaultIfEmpty(new byte[0]) .map(bodyBytes -> { Charset charset = response.headers().contentType() .map(MimeType::getCharset) .orElse(StandardCharsets.ISO_8859_1); response.statusCode().value(), response.statusCode().getReasonPhrase(), response.headers().asHttpHeaders(), bodyBytes, charset, return new UnknownHttpStatusCodeException( response.rawStatusCode(), response.headers().asHttpHeaders(), bodyBytes, charset,
protected Mono<Info> convertInfo(Instance instance, ClientResponse response) { if (response.statusCode().is2xxSuccessful() && response.headers() .contentType() .map(mt -> mt.isCompatibleWith(MediaType.APPLICATION_JSON) || mt.isCompatibleWith(ACTUATOR_V2_MEDIATYPE)) .orElse(false)) { return response.bodyToMono(RESPONSE_TYPE).map(Info::from).defaultIfEmpty(Info.empty()); } log.info("Couldn't retrieve info for {}: {}", instance, response.statusCode()); return response.bodyToMono(Void.class).then(Mono.just(Info.empty())); }
protected Mono<StatusInfo> convertStatusInfo(ClientResponse response) { Boolean hasCompatibleContentType = response.headers() .contentType() .map(mt -> mt.isCompatibleWith(MediaType.APPLICATION_JSON) || mt.isCompatibleWith(ACTUATOR_V2_MEDIATYPE)) .orElse(false); StatusInfo statusInfoFromStatus = this.getStatusInfoFromStatus(response.statusCode(), emptyMap()); if (hasCompatibleContentType) { return response.bodyToMono(RESPONSE_TYPE).map(body -> { if (body.get("status") instanceof String) { return StatusInfo.from(body); } return getStatusInfoFromStatus(response.statusCode(), body); }).defaultIfEmpty(statusInfoFromStatus); } return response.bodyToMono(Void.class).then(Mono.just(statusInfoFromStatus)); }
public DefaultClientResponseBuilder(ClientResponse other) { Assert.notNull(other, "ClientResponse must not be null"); this.strategies = other.strategies(); statusCode(other.statusCode()); headers(headers -> headers.addAll(other.headers().asHttpHeaders())); cookies(cookies -> cookies.addAll(other.cookies())); }
@Override public Mono<Endpoints> detectEndpoints(Instance instance) { Registration registration = instance.getRegistration(); String managementUrl = registration.getManagementUrl(); if (managementUrl == null || Objects.equals(registration.getServiceUrl(), managementUrl)) { return Mono.empty(); } return instanceWebClient.instance(instance) .get() .uri(managementUrl) .exchange() .flatMap(response -> { if (response.statusCode().is2xxSuccessful() && response.headers() .contentType() .map(actuatorMediaType::isCompatibleWith) .orElse(false)) { return response.bodyToMono(Response.class); } else { return response.bodyToMono(Void.class).then(Mono.empty()); } }) .flatMap(this::convert); }
private static Mono<UserInfoErrorResponse> parse(ClientResponse httpResponse) { String wwwAuth = httpResponse.headers().asHttpHeaders().getFirst(HttpHeaders.WWW_AUTHENTICATE); if (!StringUtils.isEmpty(wwwAuth)) { // Bearer token error? return Mono.fromCallable(() -> UserInfoErrorResponse.parse(wwwAuth)); } ParameterizedTypeReference<Map<String, String>> typeReference = new ParameterizedTypeReference<Map<String, String>>() {}; // Other error? return httpResponse .bodyToMono(typeReference) .map(body -> new UserInfoErrorResponse(ErrorObject.parse(new JSONObject(body)))); } }
@Test public void value() { Mono<Msg> result = this.webClient.get() .uri("/message") .exchange() .doOnNext(response -> { Assert.assertFalse(response.headers().contentType().get().getParameters().containsKey("delimited")); Assert.assertEquals("sample.proto", response.headers().header("X-Protobuf-Schema").get(0)); Assert.assertEquals("Msg", response.headers().header("X-Protobuf-Message").get(0)); }) .flatMap(response -> response.bodyToMono(Msg.class)); StepVerifier.create(result) .expectNext(TEST_MSG) .verifyComplete(); }
@RequestMapping(path = REQUEST_MAPPING_PATH, method = {RequestMethod.GET, RequestMethod.HEAD, RequestMethod.POST, RequestMethod.PUT, RequestMethod.PATCH, RequestMethod.DELETE, RequestMethod.OPTIONS}) public Mono<Void> endpointProxy(@PathVariable("instanceId") String instanceId, ServerHttpRequest request, ServerHttpResponse response) { String endpointLocalPath = getEndpointLocalPath(request.getPath().pathWithinApplication().value()); URI uri = UriComponentsBuilder.fromPath(endpointLocalPath) .query(request.getURI().getRawQuery()) .build(true) .toUri(); return super.forward(instanceId, uri, request.getMethod(), request.getHeaders(), () -> BodyInserters.fromDataBuffers(request.getBody())).flatMap(clientResponse -> { response.setStatusCode(clientResponse.statusCode()); response.getHeaders().addAll(filterHeaders(clientResponse.headers().asHttpHeaders())); return response.writeAndFlushWith(clientResponse.body(BodyExtractors.toDataBuffers()).window(1)); }); } }
@Test public void values() { Flux<Msg> result = this.webClient.get() .uri("/messages") .exchange() .doOnNext(response -> { Assert.assertEquals("true", response.headers().contentType().get().getParameters().get("delimited")); Assert.assertEquals("sample.proto", response.headers().header("X-Protobuf-Schema").get(0)); Assert.assertEquals("Msg", response.headers().header("X-Protobuf-Message").get(0)); }) .flatMapMany(response -> response.bodyToFlux(Msg.class)); StepVerifier.create(result) .expectNext(TEST_MSG) .expectNext(TEST_MSG) .expectNext(TEST_MSG) .verifyComplete(); }
@Test public void streaming() { Flux<Msg> result = this.webClient.get() .uri("/message-stream") .exchange() .doOnNext(response -> { Assert.assertEquals("true", response.headers().contentType().get().getParameters().get("delimited")); Assert.assertEquals("sample.proto", response.headers().header("X-Protobuf-Schema").get(0)); Assert.assertEquals("Msg", response.headers().header("X-Protobuf-Message").get(0)); }) .flatMapMany(response -> response.bodyToFlux(Msg.class)); StepVerifier.create(result) .expectNext(Msg.newBuilder().setFoo("Foo").setBlah(SecondMsg.newBuilder().setBlah(0).build()).build()) .expectNext(Msg.newBuilder().setFoo("Foo").setBlah(SecondMsg.newBuilder().setBlah(1).build()).build()) .thenCancel() .verify(); }
@Test public void from() { Flux<DataBuffer> otherBody = Flux.just("foo", "bar") .map(s -> s.getBytes(StandardCharsets.UTF_8)) .map(dataBufferFactory::wrap); ClientResponse other = ClientResponse.create(HttpStatus.BAD_REQUEST, ExchangeStrategies.withDefaults()) .header("foo", "bar") .cookie("baz", "qux") .body(otherBody) .build(); Flux<DataBuffer> body = Flux.just("baz") .map(s -> s.getBytes(StandardCharsets.UTF_8)) .map(dataBufferFactory::wrap); ClientResponse result = ClientResponse.from(other) .headers(httpHeaders -> httpHeaders.set("foo", "baar")) .cookies(cookies -> cookies.set("baz", ResponseCookie.from("baz", "quux").build())) .body(body) .build(); assertEquals(HttpStatus.BAD_REQUEST, result.statusCode()); assertEquals(1, result.headers().asHttpHeaders().size()); assertEquals("baar", result.headers().asHttpHeaders().getFirst("foo")); assertEquals(1, result.cookies().size()); assertEquals("quux", result.cookies().getFirst("baz").getValue()); StepVerifier.create(result.bodyToFlux(String.class)) .expectNext("baz") .verifyComplete(); }
@Test public void fixedLocale() { Mono<ClientResponse> result = webClient .get() .uri("http://localhost:" + this.port + "/") .exchange(); StepVerifier .create(result) .consumeNextWith(response -> { assertEquals(HttpStatus.OK, response.statusCode()); assertEquals(Locale.GERMANY, response.headers().asHttpHeaders().getContentLanguage()); }) .verifyComplete(); }
@Test public void fixedLocale() { Mono<ClientResponse> result = webClient .get() .uri("http://localhost:" + this.port + "/") .exchange(); StepVerifier.create(result) .consumeNextWith(response -> { assertEquals(HttpStatus.OK, response.statusCode()); assertEquals(Locale.GERMANY, response.headers().asHttpHeaders().getContentLanguage()); }) .verifyComplete(); }
@Test public void normal() { Flux<DataBuffer> body = Flux.just("baz") .map(s -> s.getBytes(StandardCharsets.UTF_8)) .map(dataBufferFactory::wrap); ClientResponse response = ClientResponse.create(HttpStatus.BAD_GATEWAY, ExchangeStrategies.withDefaults()) .header("foo", "bar") .cookie("baz", "qux") .body(body) .build(); assertEquals(HttpStatus.BAD_GATEWAY, response.statusCode()); HttpHeaders responseHeaders = response.headers().asHttpHeaders(); assertEquals("bar", responseHeaders.getFirst("foo")); assertNotNull("qux", response.cookies().getFirst("baz")); assertEquals("qux", response.cookies().getFirst("baz").getValue()); StepVerifier.create(response.bodyToFlux(String.class)) .expectNext("baz") .verifyComplete(); }
@Test public void shouldReceiveResponseHeaders() { prepareResponse(response -> response .setHeader("Content-Type", "text/plain") .setBody("Hello Spring!")); Mono<HttpHeaders> result = this.webClient.get() .uri("/greeting?name=Spring") .exchange() .map(response -> response.headers().asHttpHeaders()); StepVerifier.create(result) .consumeNextWith( httpHeaders -> { assertEquals(MediaType.TEXT_PLAIN, httpHeaders.getContentType()); assertEquals(13L, httpHeaders.getContentLength()); }) .expectComplete().verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT)); assertEquals("/greeting?name=Spring", request.getPath()); }); }
List<String> headerValues = clientResponse.headers().header("Foo"); return headerValues.isEmpty() ? Mono.error( new MyException("Response does not contain Foo header")) :