Java Code Examples for reactor.core.publisher.Mono#delay()

@Test
public void cancellation() {
	Mono<Long> mono = Mono.delay(Duration.ofSeconds(60));
	Future<Long> future = new MonoToListenableFutureAdapter<>(mono);

	assertTrue(future.cancel(true));
	assertTrue(future.isCancelled());
}
 

@Test
public void cancellation() {
	Mono<Long> mono = Mono.delay(Duration.ofSeconds(60));
	Future<Long> future = new MonoToListenableFutureAdapter<>(mono);

	assertTrue(future.cancel(true));
	assertTrue(future.isCancelled());
}
 

@Test
public void startStopStreamProcessing() throws Exception {
    Mono<?> startCommand = Mono.delay(Duration.ofSeconds(1));
    Mono<?> stopCommand = Mono.delay(Duration.ofSeconds(3));
    Flux<Long> streamOfData = Flux.interval(Duration.ofMillis(100));

    streamOfData
        .skipUntilOther(startCommand)
        .takeUntilOther(stopCommand)
        .subscribe(System.out::println);

    Thread.sleep(4000);
}
 

/**
 * TODO Add fallback to {@link Flux#timeout(Duration)}
 * It should return -1 when timeout of 100ms occurs.
 */
@Test
public void timeout() throws Exception {
	//given
	final Mono<Long> withTimeout = Mono.delay(ofMillis(200));

	//when
	final Mono<Long> withFallback = withTimeout;

	//then
	withFallback
			.as(StepVerifier::create)
			.expectNext(-1L)
			.verifyComplete();
}
 

private Mono<?> transform(ClientResponse response) {
	HttpStatus status = response.statusCode();
	if (!status.is2xxSuccessful()) {
		if (this.props.isDebug()) {
			logger.info("Delaying supplier based on status=" + response.statusCode());
		}
		return Mono.delay(Duration.ofSeconds(1));
	}
	return response.bodyToMono(this.props.getSource().getType())
			.map(value -> message(response, value));
}
 

private Mono<Long> retryMono(Duration delay) {
    if (delay == Duration.ZERO) {
        return Mono.just(0L);
    } else {
        return Mono.delay(delay, backoffScheduler);
    }
}
 

private void next(SignalType signal) {
    Mono<Long> timer = sleepTime.isZero() ? Mono.just(0L) : Mono.delay(sleepTime, timedTaskScheduler);
    timer.subscribe(l -> {
        if (log.isDebugEnabled()) {
            log.debug("[B:{}] Ready to consume next request after {}", id.toString(), signal);
        }
        sleepTime = Duration.ZERO;
        request(1);
    }, t -> log.error("[B:{}] Error while scheduling next request", id.toString(), t));
}
 

public static void main(String[] args) {
    // This variable should point to your Liiklus deployment (possible behind a Load Balancer)
    String liiklusTarget = getLiiklusTarget();

    var channel = NettyChannelBuilder.forTarget(liiklusTarget)
            .directExecutor()
            .usePlaintext()
            .build();

    var subscribeAction = SubscribeRequest.newBuilder()
            .setTopic("events-topic")
            .setGroup("my-group")
            .setAutoOffsetReset(AutoOffsetReset.EARLIEST)
            .build();

    var stub = ReactorLiiklusServiceGrpc.newReactorStub(channel);

    // Send an event every second
    Flux.interval(Duration.ofSeconds(1))
            .onBackpressureDrop()
            .concatMap(it -> stub.publish(
                    PublishRequest.newBuilder()
                            .setTopic(subscribeAction.getTopic())
                            .setKey(ByteString.copyFromUtf8(UUID.randomUUID().toString()))
                            .setLiiklusEvent(
                                    LiiklusEvent.newBuilder()
                                            .setId(UUID.randomUUID().toString())
                                            .setType("com.example.event")
                                            .setSource("/example")
                                            .setDataContentType("text/plain")
                                            .setData(ByteString.copyFromUtf8(UUID.randomUUID().toString()))
                            )
                            .build()
            ))
            .subscribe();

    // Consume the events
    Function<Integer, Function<ReceiveReply.Record, Publisher<?>>> businessLogic = partition -> record -> {
        log.info("Processing record from partition {} offset {}", partition, record.getOffset());

        // simulate processing
        return Mono.delay(Duration.ofMillis(200));
    };

    stub
            .subscribe(subscribeAction)
            .filter(it -> it.getReplyCase() == SubscribeReply.ReplyCase.ASSIGNMENT)
            .map(SubscribeReply::getAssignment)
            .doOnNext(assignment -> log.info("Assigned to partition {}", assignment.getPartition()))
            .flatMap(assignment -> stub
                    // Start receiving the events from a partition
                    .receive(ReceiveRequest.newBuilder().setAssignment(assignment).build())
                    .window(1000) // ACK every 1000th record
                    .concatMap(
                            batch -> batch
                                    .map(ReceiveReply::getRecord)
                                    .delayUntil(businessLogic.apply(assignment.getPartition()))
                                    .sample(Duration.ofSeconds(5)) // ACK every 5 seconds
                                    .onBackpressureLatest()
                                    .delayUntil(record -> {
                                        log.info("ACKing partition {} offset {}", assignment.getPartition(), record.getOffset());
                                        return stub.ack(
                                                AckRequest.newBuilder()
                                                        .setTopic(subscribeAction.getTopic())
                                                        .setGroup(subscribeAction.getGroup())
                                                        .setGroupVersion(subscribeAction.getGroupVersion())
                                                        .setPartition(assignment.getPartition())
                                                        .setOffset(record.getOffset())
                                                        .build()
                                        );
                                    }),
                            1
                    )
            )
            .blockLast();
}