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

@Test
public void reusesUntilConnectionFactoryIsClosed() {
    String url = "r2dbc:tc:postgresql:///db?TC_IMAGE_TAG=10-alpine";
    ConnectionFactory connectionFactory = ConnectionFactories.get(url);

    Integer updated = Flux
        .usingWhen(
            connectionFactory.create(),
            connection -> {
                return Mono
                    .from(connection.createStatement("CREATE TABLE test(id integer PRIMARY KEY)").execute())
                    .thenMany(connection.createStatement("INSERT INTO test(id) VALUES(123)").execute())
                    .flatMap(Result::getRowsUpdated);
            },
            Connection::close
        )
        .blockFirst();

    assertThat(updated).isEqualTo(1);

    Flux<Long> select = Flux
        .usingWhen(
            Flux.defer(connectionFactory::create),
            connection -> {
                return Flux
                    .from(connection.createStatement("SELECT COUNT(*) FROM test").execute())
                    .flatMap(it -> it.map((row, meta) -> (Long) row.get(0)));
            },
            Connection::close
        );

    Long rows = select.blockFirst();

    assertThat(rows).isEqualTo(1);

    close(connectionFactory);

    Assertions
        .assertThatThrownBy(select::blockFirst)
        .isInstanceOf(PostgresqlException.class)
        // relation "X" does not exists
        // https://github.com/postgres/postgres/blob/REL_10_0/src/backend/utils/errcodes.txt#L349
        .returns("42P01", e -> ((PostgresqlException) e).getErrorDetails().getCode());
}
 

<T> Flux<T> doInStatementRunnerForFlux(final String targetDatabase, Function<RxQueryRunner, Flux<T>> func) {

		return Flux.usingWhen(retrieveRxStatementRunnerHolder(targetDatabase),
			holder -> func.apply(holder.getRxQueryRunner()),
			RxStatementRunnerHolder::getCommit,
			(holder, ex) -> holder.getRollback(),
			RxStatementRunnerHolder::getCommit);
	}
 

@Override
public Publisher<Record> getPublisher() {
    return Flux.usingWhen(
            Mono.fromCompletionStage(() -> {
                var consumerBuilder = pulsarClient.newConsumer()
                        .acknowledgmentGroupTime(0, TimeUnit.SECONDS) // we don't ack here at all
                        .subscriptionName(groupName)
                        .subscriptionType(SubscriptionType.Failover)
                        .topic(TopicName.get(topic).getPartition(partition).toString());

                autoOffsetReset
                        .map(it -> {
                            switch (it) {
                                case "earliest":
                                    return SubscriptionInitialPosition.Earliest;
                                case "latest":
                                    return SubscriptionInitialPosition.Latest;
                                default:
                                    return null;
                            }
                        })
                        .ifPresent(consumerBuilder::subscriptionInitialPosition);

                return consumerBuilder.subscribeAsync();
            }),
            consumer -> {
                return Mono
                        .fromCompletionStage(consumer::receiveAsync)
                        .repeat()
                        .onErrorResume(AlreadyClosedException.class, __ -> Mono.empty())
                        .map(message -> {
                            var key = message.getKey();
                            return new Record(
                                    toEnvelope(topic, key, message),
                                    extractTime(message),
                                    partition,
                                    toOffset(message.getMessageId())
                            );
                        })
                        .delaySubscription(
                                initialOffset.flatMap(offset -> {
                                    return Mono.fromCompletionStage(consumer.seekAsync(fromOffset(offset)));
                                })
                        );
            },
            consumer -> Mono.fromCompletionStage(consumer.closeAsync())
    );
}
 

/**
 * Acquire a {@code POOLABLE} object from the pool upon subscription and declaratively use it, automatically releasing
 * the object back to the pool once the derived usage pipeline terminates or is cancelled. This acquire-use-and-release
 * scope is represented by a user provided {@link Function}.
 * <p>
 * This is typically useful when the resource (and its usage patterns) directly involve reactive APIs that can be
 * composed within the {@link Function} scope.
 * <p>
 * The {@link Mono} provided to the {@link Function} emits the {@code POOLABLE} as it becomes available. Cancelling
 * the {@link org.reactivestreams.Subscription} before the {@code POOLABLE} has been emitted will either avoid object
 * acquisition entirely or will translate to a {@link PooledRef#release() release} of the {@code POOLABLE}.
 *
 * @param scopeFunction the {@link Function} to apply to the {@link Mono} delivering the POOLABLE to instantiate and
 *                      trigger a processing pipeline around it
 * @return a {@link Flux}, each subscription to which represents an individual act of acquiring a pooled object,
 * processing it as declared in {@code scopeFunction} and automatically releasing it
 * @see #acquire()
 */
default <V> Flux<V> withPoolable(Function<POOLABLE, Publisher<V>> scopeFunction) {
    return Flux.usingWhen(
            acquire(),
            slot -> { POOLABLE poolable = slot.poolable();
            if (poolable == null) return Mono.empty();
            return scopeFunction.apply(poolable);
            },
            PooledRef::release,
            (ref, error) -> ref.release(),
            PooledRef::release);
}
 

/**
 * Provides a scope to perform reactive operations under this limiter resources. Resources are acquired on
 * subscription and released when the given stage has completed or terminated with an error.
 *
 * @param stage a {@link Mono} that will manage this limiter resources
 * @param <T> the type of the stage supplier
 * @return a {@link Mono} where each subscription represents acquiring a rate limiter resource
 */
public <T> Flux<T> withLimiter(Publisher<T> stage) {
    return Flux.usingWhen(
            acquire(),
            resource -> stage,
            this::release);
}