private Flux<TokenBuffer> parseTokenBufferFlux() throws IOException { List<TokenBuffer> result = new ArrayList<>(); while (true) { JsonToken token = this.parser.nextToken(); // SPR-16151: Smile data format uses null to separate documents if ((token == JsonToken.NOT_AVAILABLE) || (token == null && (token = this.parser.nextToken()) == null)) { break; } updateDepth(token); if (!this.tokenizeArrayElements) { processTokenNormal(token, result); } else { processTokenArray(token, result); } } return Flux.fromIterable(result); }
private Mono<List<View>> resolveViews(String viewName, Locale locale) { return Flux.fromIterable(getViewResolvers()) .concatMap(resolver -> resolver.resolveViewName(viewName, locale)) .collectList() .map(views -> { if (views.isEmpty()) { throw new IllegalStateException( "Could not resolve view with name '" + viewName + "'."); } views.addAll(getDefaultViews()); return views; }); }
protected Mono<Void> updateStatusForAllInstances() { log.debug("Updating status for all instances"); Instant expiryInstant = Instant.now().minus(statusLifetime); return Flux.fromIterable(lastQueried.entrySet()) .filter(e -> e.getValue().isBefore(expiryInstant)) .map(Map.Entry::getKey) .flatMap(this::updateStatus) .then(); }
@Override public Flux<InstanceEvent> find(InstanceId id) { return Flux.defer(() -> Flux.fromIterable(eventLog.getOrDefault(id, Collections.emptyList()))); }
@Override public Flux<InstanceEvent> findAll() { return Flux.defer(() -> Flux.fromIterable(eventLog.values()) .flatMapIterable(Function.identity()) .sort(byTimestampAndIdAndVersion)); }
private Mono<Resource> getResource(String resourcePath, List<? extends Resource> locations) { return Flux.fromIterable(locations) .concatMap(location -> getResource(resourcePath, location)) .next(); }
@Override public Mono<Endpoints> detectEndpoints(Instance instance) { return Flux.fromIterable(endpoints) .flatMap(endpoint -> detectEndpoint(instance, endpoint)) .collectList() .flatMap(this::convert); }
@Override public Mono<Void> notify(InstanceEvent event) { return Flux.fromIterable(delegates).flatMap(d -> d.notify(event).onErrorResume(error -> { log.warn("Unexpected exception while triggering notifications. Notification might not be sent.", error); return Mono.empty(); })).then(); } }
private Flux<DataBuffer> toDataBuffers(String s, int length, Charset charset) { byte[] bytes = s.getBytes(charset); List<DataBuffer> dataBuffers = new ArrayList<>(); for (int i = 0; i < bytes.length; i += length) { DataBuffer dataBuffer = this.bufferFactory.allocateBuffer(length); dataBuffer.write(bytes, i, length); dataBuffers.add(dataBuffer); } return Flux.fromIterable(dataBuffers); }
private Mono<WebSession> retrieveSession(ServerWebExchange exchange) { return Flux.fromIterable(getSessionIdResolver().resolveSessionIds(exchange)) .concatMap(this.sessionStore::retrieveSession) .next(); }
private Mono<Void> writeMultipart( MultiValueMap<String, ?> map, ReactiveHttpOutputMessage outputMessage, Map<String, Object> hints) { byte[] boundary = generateMultipartBoundary(); Map<String, String> params = new HashMap<>(2); params.put("boundary", new String(boundary, StandardCharsets.US_ASCII)); params.put("charset", getCharset().name()); outputMessage.getHeaders().setContentType(new MediaType(MediaType.MULTIPART_FORM_DATA, params)); LogFormatUtils.traceDebug(logger, traceOn -> Hints.getLogPrefix(hints) + "Encoding " + (isEnableLoggingRequestDetails() ? LogFormatUtils.formatValue(map, !traceOn) : "parts " + map.keySet() + " (content masked)")); Flux<DataBuffer> body = Flux.fromIterable(map.entrySet()) .concatMap(entry -> encodePartValues(boundary, entry.getKey(), entry.getValue())) .concatWith(Mono.just(generateLastLine(boundary))); return outputMessage.writeWith(body); }
private Mono<? extends Resource> transformContent(String cssContent, Resource resource, ResourceTransformerChain chain, ServerWebExchange exchange) { List<ContentChunkInfo> contentChunkInfos = parseContent(cssContent); if (contentChunkInfos.isEmpty()) { return Mono.just(resource); } return Flux.fromIterable(contentChunkInfos) .concatMap(contentChunkInfo -> { String contentChunk = contentChunkInfo.getContent(cssContent); if (contentChunkInfo.isLink() && !hasScheme(contentChunk)) { String link = toAbsolutePath(contentChunk, exchange); return resolveUrlPath(link, exchange, resource, chain).defaultIfEmpty(contentChunk); } else { return Mono.just(contentChunk); } }) .reduce(new StringWriter(), (writer, chunk) -> { writer.write(chunk); return writer; }) .map(writer -> { byte[] newContent = writer.toString().getBytes(DEFAULT_CHARSET); return new TransformedResource(resource, newContent); }); }
@Override public Mono<Void> handle(ServerWebExchange exchange) { if (this.handlerMappings == null) { return createNotFoundError(); } return Flux.fromIterable(this.handlerMappings) .concatMap(mapping -> mapping.getHandler(exchange)) .next() .switchIfEmpty(createNotFoundError()) .flatMap(handler -> invokeHandler(exchange, handler)) .flatMap(result -> handleResult(exchange, result)); }
protected Mono<Void> sendReminders() { Instant now = Instant.now(); return Flux.fromIterable(this.reminders.values()) .filter(reminder -> reminder.getLastNotification().plus(reminderPeriod).isBefore(now)) .flatMap(reminder -> delegate.notify(reminder.getEvent()) .doOnSuccess(signal -> reminder.setLastNotification(now))) .then(); }
private void testTokenize(List<String> source, List<String> expected, boolean tokenizeArrayElements) { Flux<TokenBuffer> tokenBufferFlux = Jackson2Tokenizer.tokenize( Flux.fromIterable(source).map(this::stringBuffer), this.jsonFactory, tokenizeArrayElements); Flux<String> result = tokenBufferFlux .map(tokenBuffer -> { try { TreeNode root = this.objectMapper.readTree(tokenBuffer.asParser()); return this.objectMapper.writeValueAsString(root); } catch (IOException ex) { throw new UncheckedIOException(ex); } }); StepVerifier.FirstStep<String> builder = StepVerifier.create(result); expected.forEach(s -> builder.assertNext(new JSONAssertConsumer(s))); builder.verifyComplete(); }
@Override @SuppressWarnings({"rawtypes", "unchecked"}) // on JDK 9 where XMLEventReader is Iterator<Object> public Flux<XMLEvent> decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) { Flux<DataBuffer> flux = Flux.from(inputStream); if (this.useAalto) { AaltoDataBufferToXmlEvent aaltoMapper = new AaltoDataBufferToXmlEvent(); return flux.flatMap(aaltoMapper) .doFinally(signalType -> aaltoMapper.endOfInput()); } else { Mono<DataBuffer> singleBuffer = DataBufferUtils.join(flux); return singleBuffer. flatMapMany(dataBuffer -> { try { InputStream is = dataBuffer.asInputStream(); Iterator eventReader = inputFactory.createXMLEventReader(is); return Flux.fromIterable((Iterable<XMLEvent>) () -> eventReader) .doFinally(t -> DataBufferUtils.release(dataBuffer)); } catch (XMLStreamException ex) { return Mono.error(ex); } }); } }
@Test public void writeMultipleItems() throws Exception { List<String> items = Arrays.asList("one", "two", "three"); Mono<Void> completion = Flux.fromIterable(items).as(this::sendOperator); Signal<Void> signal = completion.materialize().block(); assertNotNull(signal); assertTrue("Unexpected signal: " + signal, signal.isOnComplete()); assertEquals(3, this.writer.items.size()); assertEquals("one", this.writer.items.get(0)); assertEquals("two", this.writer.items.get(1)); assertEquals("three", this.writer.items.get(2)); assertTrue(this.writer.completed); }
@Parameters(name = "client[{0}] - server [{1}]") public static Object[][] arguments() throws IOException { WebSocketClient[] clients = new WebSocketClient[] { new TomcatWebSocketClient(), new JettyWebSocketClient(), new ReactorNettyWebSocketClient(), new UndertowWebSocketClient(Xnio.getInstance().createWorker(OptionMap.EMPTY)) }; Map<HttpServer, Class<?>> servers = new LinkedHashMap<>(); servers.put(new TomcatHttpServer(TMP_DIR.getAbsolutePath(), WsContextListener.class), TomcatConfig.class); servers.put(new JettyHttpServer(), JettyConfig.class); servers.put(new ReactorHttpServer(), ReactorNettyConfig.class); servers.put(new UndertowHttpServer(), UndertowConfig.class); Flux<WebSocketClient> f1 = Flux.fromArray(clients).concatMap(c -> Flux.just(c).repeat(servers.size())); Flux<HttpServer> f2 = Flux.fromIterable(servers.keySet()).repeat(clients.length); Flux<Class<?>> f3 = Flux.fromIterable(servers.values()).repeat(clients.length); return Flux.zip(f1, f2, f3).map(Tuple3::toArray).collectList().block() .toArray(new Object[clients.length * servers.size()][2]); }
@Test public void publisherToReactivexFlowable() { List<Integer> sequence = Arrays.asList(1, 2, 3); Publisher<Integer> source = Flux.fromIterable(sequence); Object target = getAdapter(io.reactivex.Flowable.class).fromPublisher(source); assertTrue(target instanceof io.reactivex.Flowable); assertEquals(sequence, ((io.reactivex.Flowable<?>) target).toList().blockingGet()); }
@Override @Test public void encode() { List<Pojo> list = Arrays.asList( new Pojo("foo", "bar"), new Pojo("foofoo", "barbar"), new Pojo("foofoofoo", "barbarbar")); Flux<Pojo> input = Flux.fromIterable(list); testEncode(input, Pojo.class, step -> step .consumeNextWith(expect(list, List.class))); }