.onStatus(s -> s != HttpStatus.OK, response -> { return parse(response).map(userInfoErrorResponse -> { String description = userInfoErrorResponse.getErrorObject().getDescription(); }); }) .bodyToMono(typeReference);
@Test public void getResource() { final Flux<DataBuffer> body = webClient.get() .uri(uri("/resource")) .retrieve() .bodyToFlux(DataBuffer.class); StepVerifier.create(body) .thenConsumeWhile(data -> data.readableByteCount() > 0) // An empty buffer comes last. .assertNext(data -> assertThat(data.readableByteCount()).isZero()) .expectComplete() .verify(Duration.ofSeconds(30)); }
.onStatus(s -> s != HttpStatus.OK, response -> { return parse(response).map(userInfoErrorResponse -> { String description = userInfoErrorResponse.getErrorObject().getDescription(); }); }) .bodyToMono(typeReference);
.onStatus(HttpStatus::is4xxClientError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(ClientResponseException::new) .onStatus(HttpStatus::is5xxServerError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(ClientResponseException::new) .onStatus(HttpStatus::is3xxRedirection, clientResponse -> Mono.error(new RedirectException(clientResponse.headers().header("Location").get(0)))) .bodyToMono(String.class) .doOnSuccess(result -> this.addUtxo(bitcoinAccount, result)) .block();
private Mono<TokenWrapper> doRenew(TokenWrapper tokenWrapper) { Mono<VaultResponse> exchange = webClient .post() .uri("auth/token/renew-self") .headers( httpHeaders -> httpHeaders.putAll(VaultHttpHeaders .from(tokenWrapper.token))).retrieve() .bodyToMono(VaultResponse.class); return exchange .flatMap(response -> { LoginToken renewed = LoginTokenUtil.from(response.getRequiredAuth()); if (!isExpired(renewed)) { return Mono .just(new TokenWrapper(renewed, tokenWrapper.revocable)); } if (logger.isDebugEnabled()) { Duration validTtlThreshold = getRefreshTrigger() .getValidTtlThreshold(renewed); logger.info(String .format("Token TTL (%s) exceeded validity TTL threshold (%s). Dropping token.", renewed.getLeaseDuration(), validTtlThreshold)); } else { logger.info("Token TTL exceeded validity TTL threshold. Dropping token."); } dropCurrentToken(); return EMPTY; }); }
.uri(this.url, address, new BigDecimal("1000000000000000000")) .retrieve() .onStatus(HttpStatus::is4xxClientError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(ClientResponseException::new) .onStatus(HttpStatus::is5xxServerError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(ClientResponseException::new) .onStatus(HttpStatus::is3xxRedirection, clientResponse -> Mono.error(new RedirectException(clientResponse.headers().header("Location").get(0)))) .bodyToMono(String.class) .doOnSuccess(faucetResponseDto -> ethereumAccount.setNonce(null != nonce?nonce:BigInteger.ZERO)) .doOnError(RuntimeException::new)
@Bean RouterFunction<ServerResponse> routes(Source src, WebClient client) { return route(RequestPredicates.GET("/tags"), request -> { Publisher<String> map = client .get() .uri("http://localhost:8080/hashtags") .retrieve() .bodyToFlux(HashTag.class) .map(HashTag::getTag) .map(String::toUpperCase); Publisher<String> build = HystrixCommands .from(map) .fallback(Flux.just("EEEK!")) .eager() .commandName("fallback-uppercase-tags") .build(); return ServerResponse.ok().body(build, String.class); }) .andRoute(POST("/authors"), request -> { Flux<Boolean> map = request .bodyToFlux(Author.class) .map(Author::getHandle) .map(handle -> MessageBuilder.withPayload(handle).build()) .map(msg -> src.output().send(msg)); return ServerResponse.ok().body(map, Boolean.class); }); }
private void redirectPost(EthereumAccount ethereumAccount, String uri, BigInteger nonce) { this.webClient .post() .uri(uri) .contentType(MediaType.APPLICATION_JSON_UTF8) .retrieve() .onStatus(HttpStatus::is4xxClientError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(String::new) .map(ClientResponseException::new) ) .onStatus(HttpStatus::is5xxServerError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(String::new) .map(ClientResponseException::new) ) .bodyToMono(String.class) .doOnSuccess(faucetResponseDto -> ethereumAccount.setNonce(null != nonce?nonce:BigInteger.ZERO)) .doOnError(RuntimeException::new) .block(); }
private void redirectPost(BitcoinAccount bitcoinAccount, String uri) { this.webClient .post() .uri(uri) .contentType(MediaType.APPLICATION_JSON_UTF8) .retrieve() .onStatus(HttpStatus::is4xxClientError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(String::new) .map(ClientResponseException::new) ) .onStatus(HttpStatus::is5xxServerError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(String::new) .map(ClientResponseException::new) ) .bodyToMono(String.class) .doOnSuccess(result -> this.addUtxo(bitcoinAccount, result)) .doOnError(RuntimeException::new) .block(); }
private void getFees() { BitcoinFeesRecommended recommended = this.webClient.get().retrieve() .onStatus(HttpStatus::is4xxClientError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(String::new) .map(BitcoinFeesRequestFailedException::new) ) .onStatus(HttpStatus::is5xxServerError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(String::new) .map(BitcoinFeesRequestFailedException::new) ) .bodyToMono(BitcoinFeesRecommended.class).block(); if (null != recommended) { this.priority = BigInteger.valueOf(recommended.getFastestFee()); this.normal = BigInteger.valueOf(recommended.getHalfHourFee()); this.economy = BigInteger.valueOf(recommended.getHourFee()); } }
private static Mono<Map<String, Object>> lookupSelf(WebClient webClient, VaultToken token) { return webClient .get() .uri("auth/token/lookup-self") .headers(httpHeaders -> httpHeaders.putAll(VaultHttpHeaders.from(token))) .retrieve() .bodyToMono(VaultResponse.class) .map(it -> { Assert.state(it.getData() != null, "Token response is null"); return it.getRequiredData(); }) .onErrorMap( WebClientResponseException.class, e -> { return new VaultTokenLookupException(format( "Token self-lookup", e), e); }); }
private Mono<Object> doHttpRequest(HttpRequestNode<Object> step, Object state) { HttpRequest<Object> definition = step.getDefinition(); HttpEntity<?> entity = getEntity(definition.getEntity(), state); RequestBodySpec spec; if (definition.getUri() == null) { spec = webClient.method(definition.getMethod()).uri( definition.getUriTemplate(), (Object[]) definition.getUrlVariables()); } else { spec = webClient.method(definition.getMethod()).uri(definition.getUri()); } for (Entry<String, List<String>> header : entity.getHeaders().entrySet()) { spec = spec.header(header.getKey(), header.getValue().get(0)); } if (entity.getBody() != null && !entity.getBody().equals(Undefinded.INSTANCE)) { return spec.syncBody(entity.getBody()).retrieve() .bodyToMono(definition.getResponseType()); } return spec.retrieve().bodyToMono(definition.getResponseType()); }
private void getGases() { EthGasAPI ethGasAPI = this.webClient.get().retrieve() .onStatus(HttpStatus::is4xxClientError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(String::new) .map(EthGasStationRequestFailedException::new) ) .onStatus(HttpStatus::is5xxServerError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(String::new) .map(EthGasStationRequestFailedException::new) ) .bodyToMono(EthGasAPI.class).block(); if (null != ethGasAPI) { this.priority = BigInteger.valueOf(ethGasAPI.getFastest().longValue()); this.normal = BigInteger.valueOf(ethGasAPI.getFast().longValue()); this.economy = BigInteger.valueOf(ethGasAPI.getAverage().longValue()); } }
/** * Revoke a {@link VaultToken}. * * @param token the token to revoke, must not be {@literal null}. */ protected Mono<Void> revoke(VaultToken token) { return webClient.post().uri("auth/token/revoke-self").headers(httpHeaders -> { httpHeaders.addAll(VaultHttpHeaders.from(token)); }).retrieve().bodyToMono(String.class).then() .onErrorResume(WebClientResponseException.class, e -> { logger.warn(format("Could not revoke token", e)); return Mono.empty(); }).onErrorResume(Exception.class, e -> { logger.warn("Could not revoke token", e); return Mono.empty(); }).then(); }
@Override public void afterSingletonsInstantiated() { logger.info("Initializing MongoDB store if necessary"); Flux<ZoneDescriptor> zoneDescriptors = WebClient .create(properties.getGenerator().getServiceUrl()) .get().uri("/actuator/zones") .retrieve().bodyToFlux(ZoneReport.class) .flatMapIterable(ZoneReport::getZones); // Retry if the remote service is not available yet Flux<ZoneDescriptor> resilientZoneDescriptors = zoneDescriptors.onErrorResume(ex -> zoneDescriptors.delaySubscription(Duration.ofSeconds(1)).retry(3)); mongoTemplate.collectionExists(PowerGridSample.class) .filter(available -> !available).flatMap(i -> createSampleCollection()) .then(mongoTemplate.dropCollection(ZoneDescriptor.class)) .then(mongoTemplate.createCollection(ZoneDescriptor.class)) .thenMany(resilientZoneDescriptors.flatMap(mongoTemplate::insert)) .blockLast(); }
/** * Updates the cached JWK set from the configured URL. * * @return The updated JWK set. * * @throws RemoteKeySourceException If JWK retrieval failed. */ private Mono<JWKSet> getJWKSet() { return this.webClient.get() .uri(this.jwkSetURL) .retrieve() .bodyToMono(String.class) .map(this::parse) .doOnNext(jwkSet -> this.cachedJWKSet.set(Mono.just(jwkSet))) .cache(); }
@Override public Publisher<Object> executeRequest(ReactiveHttpRequest request) { ReactiveHttpRequest requestPreprocessed = requestInterceptor.apply(request); logger.logRequest(methodTag, requestPreprocessed); long start = System.currentTimeMillis(); WebClient.ResponseSpec response = webClient.method(requestPreprocessed.method()) .uri(requestPreprocessed.uri()) .headers(httpHeaders -> setUpHeaders(requestPreprocessed, httpHeaders)) .body(provideBody(requestPreprocessed)) .retrieve() .onStatus(httpStatus -> true, resp -> handleResponseStatus(metadata.configKey(), resp, start)); if (returnPublisherType == Mono.class) { return response.bodyToMono(returnActualType).map(responseLogger(start)); } else { return response.bodyToFlux(returnActualType).map(responseLogger(start)); } }
private Flux<Void> proxyDelete(Set<String> groupMembers, String appId) { Flux<Void> flux = Flux.fromIterable(groupMembers) .filter(s -> !s.equals(getHostAndPort())) .flatMap(s -> { log.debug("proxy delete to {}", s); WebClient client = WebClient.create("http://" + s); return client.delete().uri("/pregel/" + appId) .accept(MediaType.APPLICATION_JSON) .header(X_KGRAPH_APPID, appId) .retrieve() .bodyToMono(Void.class); }); return flux; }
private Flux<String> proxyResult(Set<String> groupMembers, String appId, Flux<String> body) { Flux<String> flux = groupMembers.stream() .filter(s -> !s.equals(getHostAndPort())) .map(s -> { log.debug("proxy result to {}", s); WebClient client = WebClient.create("http://" + s); return client.get().uri("/pregel/" + appId + "/result") .accept(MediaType.TEXT_EVENT_STREAM) .header(X_KGRAPH_APPID, appId) .retrieve() .bodyToFlux(String.class); }) .reduce(body, Flux::mergeWith); return flux; }
private Flux<GraphAlgorithmStatus> proxyRun(Set<String> groupMembers, String appId, GraphAlgorithmRunRequest input) { Flux<GraphAlgorithmStatus> flux = Flux.fromIterable(groupMembers) .filter(s -> !s.equals(getHostAndPort())) .flatMap(s -> { log.debug("proxy run to {}", s); WebClient client = WebClient.create("http://" + s); return client.post().uri("/pregel/" + appId) .accept(MediaType.APPLICATION_JSON) .header(X_KGRAPH_APPID, appId) .body(Mono.just(input), GraphAlgorithmRunRequest.class) .retrieve() .bodyToMono(GraphAlgorithmStatus.class); }); return flux; }