Java Code Examples for reactor.core.publisher.Flux#from()

@Test
@Disabled // related to boot 2.1 no bean override change
public void functionRegistrar() {
	this.initializer = new AbstractSpringFunctionAdapterInitializer<Object>(FunctionRegistrar.class) {

	};
	this.initializer.initialize(null);
	Flux<?> result = Flux.from(this.initializer.apply(Flux.just(new Foo())));
	assertThat(result.blockFirst()).isInstanceOf(Bar.class);
}
 

public static void readFile(File file) {
    try (final BufferedReader br = new BufferedReader(
            new FileReader(file))) {

        Flux<String> flow = Flux.from(new FilePublisher(br));

        flow.publishOn(Schedulers.elastic())
                .subscribeOn(Schedulers.immediate())
                .subscribe(System.out::println);

    } catch (IOException e) {
        e.printStackTrace();
    }
}
 

@Test
public void fluxFromFluxSourceDoesntCallAssemblyHook() {
	final Flux<Integer> source = Flux.range(1, 10);

	//set the hook AFTER the original operators have been invoked (since they trigger assembly themselves)
	AtomicInteger wrappedCount = new AtomicInteger();
	Hooks.onEachOperator(p -> {
		wrappedCount.incrementAndGet();
		return p;
	});

	Flux.from(source);
	Assertions.assertThat(wrappedCount).hasValue(0);
}
 

@Override
public Flux<JmapResponse> process(JmapRequest request, MethodCallId methodCallId, MailboxSession mailboxSession) {
    Preconditions.checkNotNull(request);
    Preconditions.checkNotNull(methodCallId);
    Preconditions.checkNotNull(mailboxSession);
    Preconditions.checkArgument(request instanceof GetFilterRequest);

    GetFilterRequest filterRequest = (GetFilterRequest) request;

    return Flux.from(metricFactory.decorateSupplierWithTimerMetricLogP99(JMAP_PREFIX + METHOD_NAME.getName(),
        () -> process(methodCallId, mailboxSession, filterRequest)
            .subscriberContext(context("GET_FILTER", MDCBuilder.of(MDCBuilder.ACTION, "GET_FILTER")))));
}
 

/**
 * Handle request for bidirectional channel
 *
 * @param payloads Stream of payloads delivered from the client
 * @return
 */
@Override
public Flux<Payload> requestChannel(Publisher<Payload> payloads) {
    Flux.from(payloads)
      .subscribe(gameController::processPayload);
    Flux<Payload> channel = Flux.from(gameController);
    return channel;
}
 

/**
 * Handle Request/Stream messages. Each request returns a new stream.
 *
 * @param payload Payload that can be used to determine which stream to return
 * @return Flux stream containing simulated measurement data
 */
@Override
public Flux<Payload> requestStream(Payload payload) {
    String streamName = payload.getDataUtf8();
    if (DATA_STREAM_NAME.equals(streamName)) {
        return Flux.from(dataPublisher);
    }
    return Flux.error(new IllegalArgumentException(streamName));
}
 

private Flux<LiveHttpResponse> retry(
        LiveHttpRequest request,
        RetryPolicyContext retryContext,
        List<RemoteHost> previousOrigins,
        int attempt,
        Throwable cause,
        HttpInterceptor.Context context) {
    LoadBalancer.Preferences lbContext = new LoadBalancer.Preferences() {
        @Override
        public Optional<String> preferredOrigins() {
            return Optional.empty();
        }

        @Override
        public List<Origin> avoidOrigins() {
            return previousOrigins.stream()
                    .map(RemoteHost::origin)
                    .collect(Collectors.toList());
        }
    };

    if (this.retryPolicy.evaluate(retryContext, loadBalancer, lbContext).shouldRetry()) {
        return Flux.from(sendRequest(request, previousOrigins, attempt, context));
    } else {
        return Flux.error(cause);
    }
}
 

@Test
public void noDefaultConstructor() {
	Flux<DataBuffer> input =
			Flux.from(stringBuffer("{\"property1\":\"foo\",\"property2\":\"bar\"}"));
	ResolvableType elementType = forClass(BeanWithNoDefaultConstructor.class);
	Flux<Object> flux = new Jackson2JsonDecoder().decode(input, elementType, null, emptyMap());
	StepVerifier.create(flux).verifyError(CodecException.class);
}
 

public void setBody(Publisher<DataBuffer> body) {
	this.body = Flux.from(body);
}
 

@Override
public Flux<WebSocketMessage> receive() {
	return (canSuspendReceiving() ? Flux.from(this.receivePublisher) :
			Flux.from(this.receivePublisher).onBackpressureBuffer(RECEIVE_BUFFER_SIZE));
}
 

static Flux<Integer> extractId(Result result) {
    return Flux.from(result.map((row, metadata) -> row.get(0, Integer.class)));
}
 

@Override
public Flux<MessageFullView> fromMessageIds(List<MessageId> messageIds, MailboxSession mailboxSession) {
    Flux<MessageResult> messages = Flux.from(messageIdManager.getMessagesReactive(messageIds, FetchGroup.FULL_CONTENT, mailboxSession));
    return Helpers.toMessageViews(messages, this::fromMessageResults);
}
 

public static <T> ReactiveSeq<T> reactiveSeq(Publisher<T> flux){
    return new FluxReactiveSeqImpl<>(Flux.from(flux));
}
 

@PostMapping(path = "/mirrorBodyStream")
@Override
public Flux<TestObject> mirrorBodyStream(
		@RequestBody Publisher<TestObject> bodyStream) {
	return Flux.from(bodyStream);
}
 

@Override
@SuppressWarnings("ConstantConditions")
public Flux<DataBuffer> getBody() {
	return Flux.from(this.recorder.getPublisherToUse());
}
 

public JettyClientHttpResponse(ReactiveResponse reactiveResponse, Publisher<DataBuffer> content) {
	this.reactiveResponse = reactiveResponse;
	this.content = Flux.from(content);
}
 

<V, T> Flux<T> execute(Publisher<V> commands, Function<V, Publisher<T>> mapper) {
    Flux<V> s = Flux.from(commands);
    return s.concatMap(mapper);
}
 

@Override
public Flux<DataBuffer> getBody() {
	return Flux.from(this.bodyPublisher);
}
 

@Test
public void decodeEmptyArrayToFlux() {
	Flux<DataBuffer> input = Flux.from(stringBuffer("[]"));

	testDecode(input, Pojo.class, step -> step.verifyComplete());
}
 

@Test
default void processedMailsShouldNotDecreaseSize() throws Exception {
    enQueue(defaultMail().name("name").build());

    Flux.from(getManageableMailQueue().deQueue());

    long size = getManageableMailQueue().getSize();

    assertThat(size).isEqualTo(1L);
}