@Test public void header() { HttpHeaders httpHeaders = new HttpHeaders(); List<MediaType> accept = Collections.singletonList(MediaType.APPLICATION_JSON); httpHeaders.setAccept(accept); List<Charset> acceptCharset = Collections.singletonList(StandardCharsets.UTF_8); httpHeaders.setAcceptCharset(acceptCharset); long contentLength = 42L; httpHeaders.setContentLength(contentLength); MediaType contentType = MediaType.TEXT_PLAIN; httpHeaders.setContentType(contentType); InetSocketAddress host = InetSocketAddress.createUnresolved("localhost", 80); httpHeaders.setHost(host); List<HttpRange> range = Collections.singletonList(HttpRange.createByteRange(0, 42)); httpHeaders.setRange(range); DefaultServerRequest request = new DefaultServerRequest( MockServerWebExchange.from(MockServerHttpRequest .method(HttpMethod.GET, "http://example.com?foo=bar") .headers(httpHeaders)), this.messageReaders); ServerRequest.Headers headers = request.headers(); assertEquals(accept, headers.accept()); assertEquals(acceptCharset, headers.acceptCharset()); assertEquals(OptionalLong.of(contentLength), headers.contentLength()); assertEquals(Optional.of(contentType), headers.contentType()); assertEquals(httpHeaders, headers.asHttpHeaders()); }
@Test public void header() { String name = "foo"; List<String> value = Collections.singletonList("bar"); when(mockHeaders.header(name)).thenReturn(value); assertSame(value, wrapper.header(name)); }
@Test public void host() { InetSocketAddress host = InetSocketAddress.createUnresolved("example.com", 42); when(mockHeaders.host()).thenReturn(host); assertSame(host, wrapper.host()); }
@Bean RouterFunction<ServerResponse> routes() { return route(GET("/api/v1/messages"), request -> ok().contentType(request.headers() .accept() .contains(TEXT_EVENT_STREAM) ? TEXT_EVENT_STREAM : APPLICATION_STREAM_JSON) .body(Flux.zip( Flux.interval(Duration.ofSeconds(1)), messages.findAll()) .map(Tuple2::getT2) .share(), Message.class)) .andRoute(POST("/api/v1/messages"), request -> ok().contentType(APPLICATION_JSON) .body(request.bodyToMono(Message.class) .flatMap(messages::save), Message.class)) .andRoute(GET("/"), request -> ok().render("index", Rendering.view("index") .modelAttribute("name", "Max") .build() .modelAttributes()) ); }
@Bean RouterFunction<ServerResponse> routes(final Flux<ServerSentEvent<Map>> processor, final Consumer<String> distributeEvent) { final ParameterizedTypeReference<Map<String, String>> type = new ParameterizedTypeReference<Map<String, String>>() {}; return route(GET("/**"), request -> ok().contentType(request.headers().accept().contains(TEXT_EVENT_STREAM) ? TEXT_EVENT_STREAM : APPLICATION_STREAM_JSON) .body(processor.map(s -> s), ServerSentEvent.class)) .andRoute(POST("/**"), request -> accepted().body(request.bodyToMono(type) .map(map -> map.getOrDefault("message", "")) .map(String::valueOf) .map(String::trim) .filter(s -> s.length() > 0) .doOnNext(distributeEvent) .map(m -> format("message '%s' accepted.", m)) .map(message -> singletonMap("response", message)) .subscribeOn(Schedulers.elastic()) .flatMap(Mono::just), Map.class)) ; }
public Mono<ServerResponse> run(ServerRequest request) { List<String> appIdHeaders = request.headers().header(X_KGRAPH_APPID); String appId = request.pathVariable("id"); return request.bodyToMono(GraphAlgorithmRunRequest.class) .flatMapMany(input -> { log.debug("num iterations: {}", input.getNumIterations()); PregelGraphAlgorithm<Long, ?, ?, ?> algorithm = algorithms.get(appId); GraphAlgorithmState state = algorithm.run(input.getNumIterations()); GraphAlgorithmStatus status = new GraphAlgorithmStatus(state); Flux<GraphAlgorithmStatus> states = proxyRun(appIdHeaders.isEmpty() ? group.getCurrentMembers().keySet() : Collections.emptySet(), appId, input); return Mono.just(status).mergeWith(states); }) .reduce((state1, state2) -> state1) .flatMap(state -> ServerResponse.ok() .contentType(MediaType.APPLICATION_JSON) .body(Mono.just(state), GraphAlgorithmStatus.class) ); }
/** * Return a {@code RequestPredicate} that tests if the request's * {@linkplain ServerRequest.Headers#accept() accept} header is * {@linkplain MediaType#isCompatibleWith(MediaType) compatible} with any of the given media types. * * @param mediaTypes the media types to match the request's accept header against * @return a predicate that tests the request's accept header against the given media types */ public static RequestPredicate accept(MediaType... mediaTypes) { Assert.notEmpty(mediaTypes, "'mediaTypes' must not be empty"); Set<MediaType> mediaTypeSet = new HashSet<>(Arrays.asList(mediaTypes)); return headers(headers -> { List<MediaType> acceptedMediaTypes = headers.accept(); MediaType.sortBySpecificityAndQuality(acceptedMediaTypes); return acceptedMediaTypes.stream() .anyMatch(acceptedMediaType -> mediaTypeSet.stream() .anyMatch(acceptedMediaType::isCompatibleWith)); }); }
public Mono<ServerResponse> configure(ServerRequest request) { List<String> appIdHeaders = request.headers().header(X_KGRAPH_APPID); String appId = appIdHeaders.isEmpty() ? generateRandomString(8) : appIdHeaders.iterator().next(); return request.bodyToMono(GraphAlgorithmCreateRequest.class) .doOnNext(input -> { PregelGraphAlgorithm<Long, ?, ?, ?> algorithm = getAlgorithm(appId, input); StreamsBuilder builder = new StreamsBuilder(); Properties streamsConfig = streamsConfig(appId, props.getBootstrapServers(), new KryoSerde<>()); algorithm.configure(builder, streamsConfig); algorithms.put(appId, algorithm); }) .flatMapMany(input -> proxyConfigure(appIdHeaders.isEmpty() ? group.getCurrentMembers().keySet() : Collections.emptySet(), appId, input)) .then(ServerResponse.ok() .contentType(MediaType.APPLICATION_JSON) .body(Mono.just(new GraphAlgorithmId(appId)), GraphAlgorithmId.class)); }
/** * Return a {@code RequestPredicate} that tests if the request's * {@linkplain ServerRequest.Headers#contentType() content type} is {@linkplain MediaType#includes(MediaType) included} * by any of the given media types. * * @param mediaTypes the media types to match the request's content type against * @return a predicate that tests the request's content type against the given media types */ public static RequestPredicate contentType(MediaType... mediaTypes) { Assert.notEmpty(mediaTypes, "'mediaTypes' must not be empty"); Set<MediaType> mediaTypeSet = new HashSet<>(Arrays.asList(mediaTypes)); return headers(headers -> { MediaType contentType = headers.contentType().orElse(MediaType.APPLICATION_OCTET_STREAM); return mediaTypeSet.stream() .anyMatch(mediaType -> mediaType.includes(contentType)); }); }
@SuppressWarnings("unchecked") public Mono<ServerResponse> result(ServerRequest request) { List<String> appIdHeaders = request.headers().header(X_KGRAPH_APPID); String appId = request.pathVariable("id"); PregelGraphAlgorithm<Long, ?, ?, ?> algorithm = algorithms.get(appId); Flux<String> body = Flux.fromIterable(algorithm.result()).map(kv -> { log.trace("result: ({}, {})", kv.key, kv.value); return kv.key + " " + kv.value; }); body = proxyResult(appIdHeaders.isEmpty() ? group.getCurrentMembers().keySet() : Collections.emptySet(), appId, body); return ServerResponse.ok() .contentType(MediaType.TEXT_EVENT_STREAM) .body(BodyInserters.fromPublisher(body, String.class)); }
@Override public OptionalLong contentLength() { return this.headers.contentLength(); }
@Override public List<HttpRange> range() { return this.headers.range(); }
@Override public InetSocketAddress host() { return this.headers.host(); }
@Override public List<Charset> acceptCharset() { return this.headers.acceptCharset(); }
@Override public Optional<MediaType> contentType() { return this.headers.contentType(); }
@Override public List<MediaType> accept() { return this.headers.accept(); }
@Bean public RouterFunction<ServerResponse> monoRouterFunction(NameHandler nameHandler, GreetingHandler greetingHandler) { return route(GET("/"), serverRequest -> ServerResponse.ok().contentType(MediaType.TEXT_HTML).body( greetingHandler.getGreetingStringMono(serverRequest.headers().asHttpHeaders(). getAcceptLanguageAsLocales().get(0).toLanguageTag()).concatWith(Mono.just(" ")). concatWith(nameHandler.getNameStringMono()), String.class)); }
@Override public HttpHeaders asHttpHeaders() { return this.headers.asHttpHeaders(); } }
public Mono<ServerResponse> delete(ServerRequest request) { List<String> appIdHeaders = request.headers().header(X_KGRAPH_APPID); String appId = request.pathVariable("id"); PregelGraphAlgorithm<Long, ?, ?, ?> algorithm = algorithms.remove(appId); algorithm.close(); return proxyDelete(appIdHeaders.isEmpty() ? group.getCurrentMembers().keySet() : Collections.emptySet(), appId) .then(ServerResponse.noContent().build()); }
@Override public List<String> header(String headerName) { return this.headers.header(headerName); }