reactor.util.function.Tuple2 Java Exaples

Source File: R053_Concurrency.java From reactor-workshop with GNU General Public License v3.0

6 votes

/**
 * TODO Generate list of tuples, but this time by zipping ({@link Flux#zip(Publisher, Publisher)})
 * stream of domains with stream of responses.
 * Why does it fail?
 */
@Test
public void zipIsBroken() throws Exception {
	//given
	final Flux<Domain> domains = Domains.all();

	//when
	Flux<Html> responses = null; // TODO
	final Flux<Tuple2<URI, Html>> tuples = Flux.zip(
			domains.map(Domain::getUri),
			responses
	);

	//then
	final List<Tuple2<URI, Html>> list = tuples
			.collectList()
			.block();

	assertThat(list)
			.hasSize(500)
			.contains(Tuples.of(new URI("http://archive.org"), new Html("<html><title>http://archive.org</title></html>")))
			.contains(Tuples.of(new URI("http://github.com"), new Html("<html><title>http://github.com</title></html>")));

	list.forEach(pair ->
			assertThat(pair.getT2().getRaw()).contains(pair.getT1().getHost()));
}

Source File: FluxPublishMulticastTest.java From reactor-core with Apache License 2.0

6 votes

@Test
public void pairWise() {
	AssertSubscriber<Tuple2<Integer, Integer>> ts = AssertSubscriber.create();

	range(1, 9).transform(o -> zip(o, o.skip(1)))
	           .subscribe(ts);

	ts.assertValues(Tuples.of(1, 2),
			Tuples.of(2, 3),
			Tuples.of(3, 4),
			Tuples.of(4, 5),
			Tuples.of(5, 6),
			Tuples.of(6, 7),
			Tuples.of(7, 8),
			Tuples.of(8, 9))
	  .assertComplete();
}

Source File: BeanFactoryAwareFunctionRegistryMultiInOutTests.java From spring-cloud-function with Apache License 2.0

6 votes

@Bean
public Function<Tuple2<Flux<String>, Flux<Integer>>, Flux<?>[]> repeater() {

	return tuple -> {
		Flux<String> stringFlux = tuple.getT1();
		Flux<Integer> integerFlux = tuple.getT2();

		Flux<Integer> sharedIntFlux = integerFlux.publish().autoConnect(2);

		Flux<String> repeated = stringFlux
				.zipWith(sharedIntFlux)
				.flatMap(t -> Flux.fromIterable(Collections.nCopies(t.getT2(), t.getT1())));

		Flux<Integer> sum = sharedIntFlux
				.buffer(3, 1)
				.map(l -> l.stream().mapToInt(Integer::intValue).sum());

		return new Flux[] { repeated, sum };
	};
}

Source File: FluxReplayTest.java From reactor-core with Apache License 2.0

6 votes

@Test
public void cacheFluxHistoryTTL() {

	Flux<Tuple2<Long, Integer>> source = Flux.just(1, 2, 3)
	                                         .delayElements(Duration.ofMillis(1000))
	                                         .replay(2, Duration.ofMillis(2000))
	                                         .hide()
	                                         .autoConnect()
	                                         .hide()
	                                         .elapsed();

	StepVerifier.create(source)
	            .expectNoFusionSupport()
	            .then(() -> vts.advanceTimeBy(Duration.ofSeconds(3)))
	            .expectNextMatches(t -> t.getT1() == 1000 && t.getT2() == 1)
	            .expectNextMatches(t -> t.getT1() == 1000 && t.getT2() == 2)
	            .expectNextMatches(t -> t.getT1() == 1000 && t.getT2() == 3)
	            .verifyComplete();

	StepVerifier.create(source)
	            .then(() -> vts.advanceTimeBy(Duration.ofSeconds(3)))
	            .expectNextMatches(t -> t.getT1() == 0 && t.getT2() == 2)
	            .expectNextMatches(t -> t.getT1() == 0 && t.getT2() == 3)
	            .verifyComplete();

}

Source File: R043_Zip.java From reactor-workshop with GNU General Public License v3.0

6 votes

@Test
public void errorBreaksZip() throws Exception {
	//given
	final Flux<Integer> nums = Flux.just(1, 2, 3);
	final Flux<String> strs = Flux.concat(
			Flux.just("a", "b"),
			Flux.error(new RuntimeException("Opps"))
	);

	//when
	final Flux<Tuple2<Integer, String>> pairs = nums.zipWith(strs);

	//then
	pairs
			.as(StepVerifier::create)
			.expectNext(Tuples.of(1, "a"))
			.expectNext(Tuples.of(2, "b"))
			.verifyErrorMatches(e -> e.getMessage().equals("Opps"));
}

Source File: AbstractCloudFoundryTaskLauncher.java From spring-cloud-deployer-cloudfoundry with Apache License 2.0

6 votes

@Override
public int getRunningTaskExecutionCount() {

	Mono<Tuple2<String,String>> orgAndSpace = Mono.zip(organizationId, spaceId);

	Mono<ListTasksRequest> listTasksRequest = orgAndSpace.map(tuple->
			ListTasksRequest.builder()
			.state(TaskState.RUNNING)
			.organizationId(tuple.getT1())
			.spaceId(tuple.getT2())
			.build());

	return listTasksRequest.flatMap(request-> this.client.tasks().list(request))
			.map(listTasksResponse -> listTasksResponse.getPagination().getTotalResults())
			.doOnError(logError("Failed to list running tasks"))
			.doOnSuccess(count -> logger.info(String.format("There are %d running tasks", count)))
			.block(Duration.ofMillis(this.deploymentProperties.getStatusTimeout()));
}

Source File: ScannableTest.java From reactor-core with Apache License 2.0

6 votes

@Test
public void scanOrDefaultOverridesGlobalDefault() {
	Scannable emptyScannable = key -> null;

	assertThat(emptyScannable.scanOrDefault(Scannable.Attr.BUFFERED, 123)).isEqualTo(123); //global 0
	assertThat(emptyScannable.scanOrDefault(Scannable.Attr.CAPACITY, 123)).isEqualTo(123); //global 0
	assertThat(emptyScannable.scanOrDefault(Scannable.Attr.PREFETCH, 123)).isEqualTo(123); //global 0

	assertThat(emptyScannable.scanOrDefault(Scannable.Attr.LARGE_BUFFERED, 123L)).isEqualTo(123L); //global null
	assertThat(emptyScannable.scanOrDefault(Scannable.Attr.REQUESTED_FROM_DOWNSTREAM, 123L)).isEqualTo(123L); //global 0

	assertThat(emptyScannable.scanOrDefault(Scannable.Attr.CANCELLED, true)).isTrue(); //global false
	assertThat(emptyScannable.scanOrDefault(Scannable.Attr.DELAY_ERROR, true)).isTrue(); //global false
	assertThat(emptyScannable.scanOrDefault(Scannable.Attr.TERMINATED, true)).isTrue(); //global false

	assertThat(emptyScannable.scanOrDefault(Scannable.Attr.ERROR, new IllegalStateException())).isInstanceOf(IllegalStateException.class); //global null

	assertThat(emptyScannable.scanOrDefault(Scannable.Attr.ACTUAL, Scannable.Attr.NULL_SCAN)).isSameAs(Scannable.Attr.NULL_SCAN); //global null
	assertThat(emptyScannable.scanOrDefault(Scannable.Attr.PARENT, Scannable.Attr.NULL_SCAN)).isSameAs(Scannable.Attr.NULL_SCAN); // global null

	List<Tuple2<String, String>> tags = Collections.singletonList(Tuples.of("some", "key"));
	assertThat(emptyScannable.scanOrDefault(Scannable.Attr.TAGS, tags.stream())).containsExactlyElementsOf(tags); //global null
	assertThat(emptyScannable.scanOrDefault(Scannable.Attr.NAME, "SomeName")).isEqualTo("SomeName"); // global null
}

Source File: PendingRequestRSocket.java From spring-cloud-rsocket with Apache License 2.0

6 votes

/**
 * After processor receives onNext signal, get route from exchange attrs, create a new
 * exchange from payload. Copy exchange attrs. Execute filter chain, if successful,
 * execute request.
 * @param logCategory log category
 * @param payload payload.
 * @return
 */
protected Mono<Tuple2<RSocket, Success>> processor(String logCategory,
		Payload payload) {
	return rSocketProcessor
			.log(PendingRequestRSocket.class.getName() + "." + logCategory,
					Level.FINEST)
			.flatMap(rSocket -> {
				GatewayExchange exchange = GatewayExchange.fromPayload(REQUEST_STREAM,
						payload, metadataExtractor);
				exchange.getAttributes().put(ROUTE_ATTR, route);
				// exchange.getAttributes().putAll(pendingExchange.getAttributes());
				return Mono.just(rSocket)
						.zipWith(executeFilterChain(route.getFilters(), exchange));
			});

}

Source File: FluxMergingTests.java From spring-in-action-5-samples with Apache License 2.0

6 votes

@Test
public void zipFluxes() {
  Flux<String> characterFlux = Flux
      .just("Garfield", "Kojak", "Barbossa");
  Flux<String> foodFlux = Flux
      .just("Lasagna", "Lollipops", "Apples");
  
  Flux<Tuple2<String, String>> zippedFlux = 
      Flux.zip(characterFlux, foodFlux);
  
  StepVerifier.create(zippedFlux)
        .expectNextMatches(p -> 
            p.getT1().equals("Garfield") && 
            p.getT2().equals("Lasagna"))
        .expectNextMatches(p -> 
            p.getT1().equals("Kojak") && 
            p.getT2().equals("Lollipops"))
        .expectNextMatches(p -> 
            p.getT1().equals("Barbossa") && 
            p.getT2().equals("Apples"))
        .verifyComplete();
}

Source File: R047_TimestampIndex.java From reactor-workshop with GNU General Public License v3.0

6 votes

@Test
public void timestamp() throws Exception {
	//given
	final Flux<String> ticker = Flux
			.interval(ofMillis(123))
			.map(lng -> "Item-" + lng);

	//when
	final Flux<Tuple2<Long, String>> stamped = ticker.timestamp();

	//then
	final Flux<Tuple2<Instant, String>> instants = stamped
			.map(tup -> tup.mapT1(Instant::ofEpochMilli));

	instants
			.subscribe(
					x -> log.info("Received {}", x)
			);

	TimeUnit.SECONDS.sleep(4);
}

Source File: FunctionDeployerTests.java From spring-cloud-function with Apache License 2.0

6 votes

@Test
public void testBootAppWithMultipleInputOutput() {
	String[] args = new String[] {
			"--spring.cloud.function.location=target/it/bootapp-multi/target/bootapp-multi-1.0.0.RELEASE-exec.jar",
			"--spring.cloud.function.function-name=fn"
	};
	ApplicationContext context = SpringApplication.run(DeployerApplication.class, args);
	FunctionCatalog catalog = context.getBean(FunctionCatalog.class);

	Function<Tuple2<Flux<Message<byte[]>>, Flux<Message<byte[]>>>, Flux<Message<byte[]>>> multiInputFunction = catalog
			.lookup("fn", "application/json");

	Message<byte[]> carEventMessage = MessageBuilder.withPayload("{\"carEvent\":\"CAR IS BUILT\"}".getBytes()).build();
	Message<byte[]> checkoutEventMessage = MessageBuilder.withPayload("{\"checkoutEvent\":\"CAR IS CHECKED OUT\"}".getBytes()).build();
	Flux<Message<byte[]>> carEventStream = Flux.just(carEventMessage);
	Flux<Message<byte[]>> checkoutEventStream = Flux.just(checkoutEventMessage);

	Flux<Message<byte[]>> result = multiInputFunction.apply(Tuples.of(carEventStream, checkoutEventStream));

	byte[] resutBytes = result.blockFirst().getPayload();
	assertThat(resutBytes).isEqualTo("{\"orderEvent\":\"CartEvent: CAR IS BUILT- CheckoutEvent: CAR IS CHECKED OUT\"}".getBytes());
}

Source File: FluxReplayTest.java From reactor-core with Apache License 2.0

6 votes

@Test
public void cacheFluxFused() {

	Flux<Tuple2<Long, Integer>> source = Flux.just(1, 2, 3)
	                                         .delayElements(Duration.ofMillis(1000))
	                                         .replay()
	                                         .autoConnect()
	                                         .elapsed();

	StepVerifier.create(source)
	            .expectFusion(Fuseable.ANY)
	            .then(() -> vts.advanceTimeBy(Duration.ofSeconds(3)))
	            .expectNextMatches(t -> t.getT1() == 1000 && t.getT2() == 1)
	            .expectNextMatches(t -> t.getT1() == 1000 && t.getT2() == 2)
	            .expectNextMatches(t -> t.getT1() == 1000 && t.getT2() == 3)
	            .verifyComplete();

	StepVerifier.create(source)
	            .expectFusion(Fuseable.ANY)
	            .then(() -> vts.advanceTimeBy(Duration.ofSeconds(3)))
	            .expectNextMatches(t -> t.getT1() == 0 && t.getT2() == 1)
	            .expectNextMatches(t -> t.getT1() == 0 && t.getT2() == 2)
	            .expectNextMatches(t -> t.getT1() == 0 && t.getT2() == 3)
	            .verifyComplete();

}

Source File: SimpleFifoPoolTest.java From reactor-pool with Apache License 2.0

6 votes

@Test
@DisplayName("acquire delays instead of allocating past maxSize")
void acquireDelaysNotAllocate() {
    AtomicInteger newCount = new AtomicInteger();
    SimpleFifoPool<PoolableTest> pool = new SimpleFifoPool<>(poolableTestConfig(2, 3,
            Mono.defer(() -> Mono.just(new PoolableTest(newCount.incrementAndGet())))));

    pool.withPoolable(poolable -> Mono.just(poolable).delayElement(Duration.ofMillis(500))).subscribe();
    pool.withPoolable(poolable -> Mono.just(poolable).delayElement(Duration.ofMillis(500))).subscribe();
    pool.withPoolable(poolable -> Mono.just(poolable).delayElement(Duration.ofMillis(500))).subscribe();

    final Tuple2<Long, PoolableTest> tuple2 = pool.withPoolable(Mono::just).elapsed().blockLast();

    assertThat(tuple2).isNotNull();

    assertThat(tuple2.getT1()).as("pending for 500ms").isCloseTo(500L, Offset.offset(50L));
    assertThat(tuple2.getT2().usedUp).as("discarded twice").isEqualTo(2);
    assertThat(tuple2.getT2().id).as("id").isLessThan(4);
}

Source File: ScannableTest.java From reactor-core with Apache License 2.0

6 votes

@Test
public void taggedFluxTest() {
	Flux<Integer> tagged1 =
			Flux.range(1, 10)
			    .tag("1", "One");


	Flux<Integer> tagged2 = tagged1.filter(i -> i % 3 == 0)
	                               .tag("2", "Two")
	                               .hide();

	final Stream<Tuple2<String, String>> scannedTags1 = Scannable.from(tagged1).tags();
	assertThat(scannedTags1.iterator())
			.containsExactlyInAnyOrder(Tuples.of("1", "One"));

	final Stream<Tuple2<String, String>> scannedTags2 = Scannable.from(tagged2).tags();
	assertThat(scannedTags2.iterator())
			.containsExactlyInAnyOrder(Tuples.of("1", "One"), Tuples.of( "2", "Two"));
}

Source File: Migration_2018_12_13_SnapshotNodeId.java From linstor-server with GNU General Public License v3.0

6 votes

private void markFailed(Connection connection, Collection<Tuple2<String, String>> failedSnapshotDefinitions)
    throws Exception
{
    ResultSet resultSet = connection.createStatement(
        ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE).executeQuery(SD_SELECT_ALL);
    while (resultSet.next())
    {
        String rscName = resultSet.getString(SD_RES_NAME);
        String snapshotName = resultSet.getString(SD_NAME);
        if (failedSnapshotDefinitions.contains(Tuples.of(rscName, snapshotName)))
        {
            resultSet.updateLong(SD_FLAGS,
                (resultSet.getLong(SD_FLAGS) & ~SD_FLAG_SUCCESSFUL) | SD_FLAG_FAILED_DEPLOYMENT
            );
            resultSet.updateRow();
        }
    }
    resultSet.close();
}

Source File: FluxReplayTest.java From reactor-core with Apache License 2.0

6 votes

@Test
public void cacheFluxHistoryTTLFused() {
	Flux<Tuple2<Long, Integer>> source = Flux.just(1, 2, 3)
	                                         .delayElements(Duration.ofMillis(1000))
	                                         .replay(2, Duration.ofMillis(2000))
	                                         .autoConnect()
	                                         .elapsed();

	StepVerifier.create(source)
	            .expectFusion(Fuseable.ANY)
	            .then(() -> vts.advanceTimeBy(Duration.ofSeconds(3)))
	            .expectNextMatches(t -> t.getT1() == 1000 && t.getT2() == 1)
	            .expectNextMatches(t -> t.getT1() == 1000 && t.getT2() == 2)
	            .expectNextMatches(t -> t.getT1() == 1000 && t.getT2() == 3)
	            .verifyComplete();

	StepVerifier.create(source)
	            .expectFusion(Fuseable.ANY)
	            .then(() -> vts.advanceTimeBy(Duration.ofSeconds(3)))
	            .expectNextMatches(t -> t.getT1() == 0 && t.getT2() == 2)
	            .expectNextMatches(t -> t.getT1() == 0 && t.getT2() == 3)
	            .verifyComplete();
}

Source File: ArgsTest.java From rsc with Apache License 2.0

6 votes

@Test
void metadataComposite() {
	final Args args = new Args(new String[]{"tcp://localhost:8080", //
			"--metadataMimeType", "application/json", //
			"-m", "{\"hello\":\"world\"}", //
			"--metadataMimeType", "text/plain", //
			"-m", "bar"});
	final Tuple2<String, ByteBuf> metadata = args.composeMetadata();
	assertThat(metadata.getT1()).isEqualTo("message/x.rsocket.composite-metadata.v0");
	assertThat(metadata.getT2().toString(UTF_8)).doesNotContain("application/json");
	assertThat(metadata.getT2().toString(UTF_8)).contains("{\"hello\":\"world\"}");
	assertThat(metadata.getT2().toString(UTF_8)).doesNotContain("text/plain");
	assertThat(metadata.getT2().toString(UTF_8)).contains("bar");
	final List<ByteBuf> metadataList = args.metadata();
	final List<String> metadataMimeTypeList = args.metadataMimeType();
	assertThat(metadataList.stream().map(x -> x.toString(UTF_8)).collect(toList()))
			.containsExactly("{\"hello\":\"world\"}", "bar");
	assertThat(metadataMimeTypeList).containsExactly("application/json", "text/plain");
}

Source File: FluxIndexTest.java From reactor-core with Apache License 2.0

5 votes

@Test
public void doNotCallToString() {
	Flux<ThrowsOnToString> source = Flux.just(new ThrowsOnToString());
	Flux<Tuple2<Long, ThrowsOnToString>> test = new FluxIndex<>(source, Flux.tuple2Function());

	StepVerifier.create(test)
			.expectNextCount(1)
			.verifyComplete();
}

Source File: OrderingFluxTest.java From linstor-server with GNU General Public License v3.0

5 votes

@Test
public void testOrderedOutOfOrderAhead()
{
    Flux<Tuple2<Long, String>> flux = Flux
        .just(of(2L, "foo"), of(0L, "bar"), of(1L, "baz"))
        .concatWith(Flux.error(new RuntimeException()));

    StepVerifier.create(OrderingFlux.order(flux))
        .expectNext("bar")
        .expectNext("baz")
        .expectNext("foo")
        .expectError()
        .verify();
}

Source File: FluxIndexTest.java From reactor-core with Apache License 2.0

5 votes

@Override
protected List<Scenario<Integer, Tuple2<Long, Integer>>> scenarios_operatorSuccess() {
	return Arrays.asList(
			scenario(Flux::index),
			scenario(f -> f.index(Tuples::of))
	);
}

Source File: R2dbcAppMetricsRepositoryTest.java From cf-butler with Apache License 2.0

5 votes

@Test
public void testByOrganization() {
    Flux<Tuple2<String, Long>> input = metricsRepo.byOrganization();
    StepVerifier.create(input)
        .assertNext(m -> {
            assertEquals(1L, m.getT2());
            assertEquals("zoo-labs", m.getT1());
        }).verifyComplete();
}

Source File: WatchStoreImpl.java From linstor-server with GNU General Public License v3.0

5 votes

@Override
public void removeWatchForPeerAndId(String peerId, Integer peerWatchId)
{
    Map<Integer, Tuple2<Watch, Disposable>> watchesForPeer = watchesByPeer.get(peerId);
    if (watchesForPeer != null)
    {
        Tuple2<Watch, Disposable> watch = watchesForPeer.remove(peerWatchId);
        if (watch != null)
        {
            removeWatches(Collections.singleton(watch));
        }
    }
}

Source File: CtrlResponseUtils.java From linstor-server with GNU General Public License v3.0

5 votes

/**
 * Combine responses from multiple nodes.
 * <p>
 * When the response from the node is successful, it is replaced with the given message.
 * <p>
 * When failures occur they are converted into responses and a {@link CtrlResponseUtils.DelayedApiRcException}
 * is emitted after all the updates have terminated.
 */
public static Flux<ApiCallRc> combineResponses(
    Flux<Tuple2<NodeName, Flux<ApiCallRc>>> responses,
    ResourceName rscName,
    String messageFormat
)
{
    return combineResponses(responses, rscName, Collections.emptySet(), messageFormat, messageFormat);
}

Source File: R043_Zip.java From reactor-workshop with GNU General Public License v3.0

5 votes

@Test
public void monoCompleted() throws Exception {
	//given
	final Mono<Integer> num = Mono.just(1);
	final Mono<String> str = Mono.just("a");

	//when
	final Mono<Tuple2<Integer, String>> pair = num.zipWith(str);

	//then
	assertThat(pair.block()).isNotNull();
}

Source File: CtrlSatelliteUpdateCaller.java From linstor-server with GNU General Public License v3.0

5 votes

/**
 * See {@link CtrlSatelliteUpdateCaller}.
 */
public Flux<Tuple2<NodeName, Flux<ApiCallRc>>> updateSatellites(
    Resource rsc,
    Publisher<ApiCallRc> nextStepRef
)
{
    return updateSatellites(rsc.getDefinition(), nextStepRef);
}

Source File: ApplicationController.java From Moss with Apache License 2.0

5 votes

protected Mono<MossApplication> toApplication(String name, Flux<Instance> instances) {
    return instances.collectList().map(instanceList -> {
        MossApplication group = new MossApplication(name);
        group.setInstances(instanceList);
        group.setRegisterSource(instanceList.get(0).getRegistration().getSource());
        group.setInstanceNum(instanceList.size());
        group.setBuildVersion(getBuildVersion(instanceList));
        Tuple2<String, Instant> status = getStatus(instanceList);
        group.setStatus(status.getT1());
        group.setStatusTimestamp(status.getT2());
        return group;
    });
}

Source File: MonoZipTest.java From reactor-core with Apache License 2.0

5 votes

@Test
public void pairWise() {
	Mono<Tuple2<Integer, String>> f = Mono.just(1)
	                                      .zipWith(Mono.just("test2"));

	Assert.assertTrue(f instanceof MonoZip);
	MonoZip<?, ?> s = (MonoZip<?, ?>) f;
	Assert.assertTrue(s.sources != null);
	Assert.assertTrue(s.sources.length == 2);

	f.subscribeWith(AssertSubscriber.create())
	 .assertValues(Tuples.of(1, "test2"))
	 .assertComplete();
}

Source File: FluxIndexedFuseableTest.java From reactor-core with Apache License 2.0

5 votes

@Test
public void indexMapperThrows() {
	Flux<String> source = Flux.just("foo", "bar");
	Flux<Tuple2<Integer, String>> test = new FluxIndexFuseable<>(source,
			(i, v) -> {
				if (i == 0L) return Tuples.of(0, v);
				throw new IllegalStateException("boom-" + i);
			});

	StepVerifier.create(test)
	            .expectNext(Tuples.of(0, "foo"))
	            .verifyErrorSatisfies(e -> assertThat(e)
			            .isInstanceOf(IllegalStateException.class)
			            .hasMessage("boom-1"));
}

Source File: MovieService.java From spring-5-examples with MIT License

5 votes

public Flux<MovieEvent> streamEvents(final String id) {
  val movie = getById(id);
  return movie.flatMapMany(s -> {
    val interval = Flux.interval(Duration.ofSeconds(1));
    val stream = Stream.generate(() -> new MovieEvent(s, now()));
    val event = Flux.fromStream(stream);
    val tuple2Flux = Flux.zip(interval, event);
    return tuple2Flux.map(Tuple2::getT2);
  });
}

Source File: HygienePolicyExecutorTask.java From cf-butler with Apache License 2.0

5 votes

private void notifyUsers(Tuple2<HygienePolicy, Workloads> tuple) {
    if (tuple.getT1().getNotifyeeTemplate() != null) {
        // Pull distinct Set<Space> from applications and service instances
        Flux
            .fromIterable(getSpaces(tuple.getT2()))
        // For each Space in Set<Space>, obtain SpaceUsers#getUsers()
            .concatMap(space -> spaceUsersService.findByOrganizationAndSpace(space.getOrganizationName(), space.getSpaceName()))
        // then pair with matching space(s) that contain applications and service instances
            .concatMap(spaceUser -> Flux.fromIterable(spaceUser.getUsers()))
            .distinct()
        // filter out account names that are not email addresses
            .filter(userName -> EmailValidator.isValid(userName))
            .concatMap(userName -> userSpacesService.getUserSpaces(userName))
        // Create a list where each item is a tuple of user account and filtered workloads
            .concatMap(userSpace -> filterWorkloads(userSpace, tuple.getT2()))
            .delayElements(Duration.ofMillis(250))
            .doOnNext(
                    userWorkloads -> {
                                publisher.publishEvent(
                                    new EmailNotificationEvent(this)
                                        .domain(settings.getAppsDomain())
                                        .from(tuple.getT1().getNotifyeeTemplate().getFrom())
                                        .recipient(userWorkloads.getT1().getAccountName())
                                        .subject(tuple.getT1().getNotifyeeTemplate().getSubject())
                                        .body(tuple.getT1().getNotifyeeTemplate().getBody())
                                        .attachments(buildAttachments(Tuples.of(tuple.getT1(), userWorkloads.getT2())))
                                );
                    }
            )
            .subscribe();
    }
}

reactor.util.function.Tuple2 Java Examples