diff --git a/acceptance/async-tests/src/test/java/org/reactivecommons/test/CommandsProcessPerfTest.java b/acceptance/async-tests/src/test/java/org/reactivecommons/test/CommandsProcessPerfTest.java index d1afdf0d..c4f974a1 100644 --- a/acceptance/async-tests/src/test/java/org/reactivecommons/test/CommandsProcessPerfTest.java +++ b/acceptance/async-tests/src/test/java/org/reactivecommons/test/CommandsProcessPerfTest.java @@ -27,7 +27,7 @@ class CommandsProcessPerfTest { private static final String COMMAND_NAME = "app.command.test"; - private static final int messageCount = 40000; + private static final int MESSAGE_COUNT = 40000; private static final Semaphore semaphore = new Semaphore(0); private static final CountDownLatch latch = new CountDownLatch(12 + 1); @@ -41,18 +41,18 @@ class CommandsProcessPerfTest { @Test void commandShouldArrive() throws InterruptedException { final long init_p = System.currentTimeMillis(); - createMessages(messageCount); + createMessages(MESSAGE_COUNT); final long end_p = System.currentTimeMillis() - init_p; System.out.println("Total Publication Time: " + end_p + "ms"); latch.countDown(); final long init = System.currentTimeMillis(); - semaphore.acquire(messageCount); + semaphore.acquire(MESSAGE_COUNT); final long end = System.currentTimeMillis(); final long total = end - init; - final double microsPerMessage = ((total + 0.0) / messageCount) * 1000; - System.out.println("Message count: " + messageCount); + final double microsPerMessage = ((total + 0.0) / MESSAGE_COUNT) * 1000; + System.out.println("Message count: " + MESSAGE_COUNT); System.out.println("Total Execution Time: " + total + "ms"); System.out.println("Microseconds per message: " + microsPerMessage + "us"); if (System.getProperty("env.ci") == null) { @@ -82,7 +82,10 @@ public static void main(String[] args) { @Bean public HandlerRegistry registry() { - final HandlerRegistry registry = range(0, 20).reduce(HandlerRegistry.register(), (r, i) -> r.handleCommand("app.command.name" + i, message -> Mono.empty(), Map.class)).block(); + final HandlerRegistry registry = range(0, 20) + .reduce(HandlerRegistry.register(), (r, i) -> + r.handleCommand("app.command.name" + i, message -> Mono.empty(), Map.class)) + .block(); return registry .handleCommand(COMMAND_NAME, this::handleSimple, DummyMessage.class); } diff --git a/acceptance/async-tests/src/test/java/org/reactivecommons/test/DirectGatewayPerfTest.java b/acceptance/async-tests/src/test/java/org/reactivecommons/test/DirectGatewayPerfTest.java index 0e4ade8c..208277a5 100644 --- a/acceptance/async-tests/src/test/java/org/reactivecommons/test/DirectGatewayPerfTest.java +++ b/acceptance/async-tests/src/test/java/org/reactivecommons/test/DirectGatewayPerfTest.java @@ -24,7 +24,7 @@ class DirectGatewayPerfTest { private static final String COMMAND_NAME = "app.command.test"; - private static final int messageCount = 40000; + private static final int MESSAGE_COUNT = 40000; private static final Semaphore semaphore = new Semaphore(0); @Autowired @@ -36,17 +36,17 @@ class DirectGatewayPerfTest { @Test void shouldSendInOptimalTime() throws InterruptedException { - final Flux> messages = createMessages(messageCount); + final Flux> messages = createMessages(MESSAGE_COUNT); final Flux target = messages.flatMap(dummyMessageCommand -> gateway.sendCommand(dummyMessageCommand, appName) .doOnSuccess(aVoid -> semaphore.release())); final long init = System.currentTimeMillis(); target.subscribe(); - semaphore.acquire(messageCount); + semaphore.acquire(MESSAGE_COUNT); final long end = System.currentTimeMillis(); - assertMessageThroughput(end - init, messageCount, 200); + assertMessageThroughput(end - init, MESSAGE_COUNT, 200); } @Test @@ -67,8 +67,10 @@ void shouldSendBatchInOptimalTime1Channel() throws InterruptedException { private void shouldSendBatchInOptimalTimeNChannels(int channels) throws InterruptedException { List> subs = new ArrayList<>(channels); for (int i = 0; i < channels; ++i) { - final Flux> messages = createMessages(messageCount / channels); - final Mono target = gateway.sendCommands(messages, appName).then().doOnSuccess(_v -> semaphore.release()); + final Flux> messages = createMessages(MESSAGE_COUNT / channels); + final Mono target = gateway.sendCommands(messages, appName) + .then() + .doOnSuccess(_v -> semaphore.release()); subs.add(target); } @@ -79,7 +81,7 @@ private void shouldSendBatchInOptimalTimeNChannels(int channels) throws Interrup final long end = System.currentTimeMillis(); final long total = end - init; - assertMessageThroughput(total, messageCount, 230); + assertMessageThroughput(total, MESSAGE_COUNT, 230); } private void assertMessageThroughput(long total, long messageCount, int reqMicrosPerMessage) { @@ -94,7 +96,9 @@ private void assertMessageThroughput(long total, long messageCount, int reqMicro } private Flux> createMessages(int count) { - final List> commands = IntStream.range(0, count).mapToObj(value -> new Command<>(COMMAND_NAME, UUID.randomUUID().toString(), new DummyMessage())).collect(Collectors.toList()); + final List> commands = IntStream.range(0, count) + .mapToObj(value -> new Command<>(COMMAND_NAME, UUID.randomUUID().toString(), new DummyMessage())) + .collect(Collectors.toList()); return Flux.fromIterable(commands); } diff --git a/acceptance/async-tests/src/test/java/org/reactivecommons/test/DynamicRegistryTest.java b/acceptance/async-tests/src/test/java/org/reactivecommons/test/DynamicRegistryTest.java index d5a94a4e..1d6e380b 100644 --- a/acceptance/async-tests/src/test/java/org/reactivecommons/test/DynamicRegistryTest.java +++ b/acceptance/async-tests/src/test/java/org/reactivecommons/test/DynamicRegistryTest.java @@ -13,7 +13,7 @@ import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.test.context.SpringBootTest; -import reactor.core.publisher.UnicastProcessor; +import reactor.core.publisher.Sinks; import reactor.test.StepVerifier; import java.time.Duration; @@ -35,21 +35,20 @@ class DynamicRegistryTest { @Test void shouldReceiveResponse() { - UnicastProcessor result = UnicastProcessor.create(); - DomainEventHandler fn = message -> fromRunnable(() -> result.onNext(message.getData())); + Sinks.Many result = Sinks.many().unicast().onBackpressureBuffer(); + DomainEventHandler fn = message -> fromRunnable( + () -> result.emitNext(message.getData(), Sinks.EmitFailureHandler.FAIL_FAST) + ); dynamicRegistry.listenEvent("test.event", fn, String.class).block(); final Publisher emit = eventBus.emit(new DomainEvent<>("test.event", "42", "Hello")); from(emit).block(); - StepVerifier.create(result.next().timeout(Duration.ofSeconds(10))) + StepVerifier.create(result.asFlux().next().timeout(Duration.ofSeconds(10))) .expectNext("Hello") .verifyComplete(); - - } - @SpringBootApplication @EnableMessageListeners @EnableDomainEventBus @@ -57,6 +56,5 @@ static class App { public static void main(String[] args) { SpringApplication.run(App.class, args); } - } } diff --git a/acceptance/async-tests/src/test/java/org/reactivecommons/test/QueryProcessPerfTest.java b/acceptance/async-tests/src/test/java/org/reactivecommons/test/QueryProcessPerfTest.java index 7fafa565..cc85ac89 100644 --- a/acceptance/async-tests/src/test/java/org/reactivecommons/test/QueryProcessPerfTest.java +++ b/acceptance/async-tests/src/test/java/org/reactivecommons/test/QueryProcessPerfTest.java @@ -30,7 +30,7 @@ class QueryProcessPerfTest { private static final String QUERY_NAME = "app.command.test"; - private static final int messageCount = 40000; + private static final int MESSAGE_COUNT = 40000; private static final Semaphore semaphore = new Semaphore(0); private static final AtomicLong atomicLong = new AtomicLong(0); private static final CountDownLatch latch = new CountDownLatch(12 + 1); @@ -44,19 +44,20 @@ class QueryProcessPerfTest { @Test void serveQueryPerformanceTest() throws InterruptedException { - final Flux> messages = createMessages(messageCount); + final Flux> messages = createMessages(MESSAGE_COUNT); final long init = System.currentTimeMillis(); messages - .flatMap(dummyMessageAsyncQuery -> gateway.requestReply(dummyMessageAsyncQuery, appName, DummyMessage.class) - .doOnNext(s -> semaphore.release()) + .flatMap(dummyMessageAsyncQuery -> + gateway.requestReply(dummyMessageAsyncQuery, appName, DummyMessage.class) + .doOnNext(s -> semaphore.release()) ) .subscribe(); - semaphore.acquire(messageCount); + semaphore.acquire(MESSAGE_COUNT); final long end = System.currentTimeMillis(); final long total = end - init; - assertMessageThroughput(total, messageCount, 200); + assertMessageThroughput(total, MESSAGE_COUNT, 200); } private void assertMessageThroughput(long total, long messageCount, int reqMicrosPerMessage) { @@ -72,7 +73,9 @@ private void assertMessageThroughput(long total, long messageCount, int reqMicro private Flux> createMessages(int count) { - final List> queryList = IntStream.range(0, count).mapToObj(_v -> new AsyncQuery<>(QUERY_NAME, new DummyMessage())).collect(Collectors.toList()); + final List> queryList = IntStream.range(0, count) + .mapToObj(_v -> new AsyncQuery<>(QUERY_NAME, new DummyMessage())) + .collect(Collectors.toList()); return Flux.fromIterable(queryList); } @@ -87,7 +90,11 @@ public static void main(String[] args) { @Bean public HandlerRegistry registry() { - final HandlerRegistry registry = range(0, 20).reduce(HandlerRegistry.register(), (r, i) -> r.handleCommand("app.command.name" + i, message -> Mono.empty(), Map.class)).block(); + final HandlerRegistry registry = range(0, 20) + .reduce(HandlerRegistry.register(), (r, i) -> r.handleCommand( + "app.command.name" + i, message -> Mono.empty(), Map.class + )) + .block(); return registry .serveQuery(QUERY_NAME, this::handleSimple, DummyMessage.class); } diff --git a/acceptance/async-tests/src/test/java/org/reactivecommons/test/SimpleDirectCommunicationTest.java b/acceptance/async-tests/src/test/java/org/reactivecommons/test/SimpleDirectCommunicationTest.java index d8aa74cf..06abd8e8 100644 --- a/acceptance/async-tests/src/test/java/org/reactivecommons/test/SimpleDirectCommunicationTest.java +++ b/acceptance/async-tests/src/test/java/org/reactivecommons/test/SimpleDirectCommunicationTest.java @@ -15,7 +15,7 @@ import org.springframework.boot.test.context.SpringBootTest; import org.springframework.context.annotation.Bean; import reactor.core.publisher.Mono; -import reactor.core.publisher.UnicastProcessor; +import reactor.core.publisher.Sinks; import reactor.test.StepVerifier; import java.time.Duration; @@ -36,20 +36,18 @@ class SimpleDirectCommunicationTest { @Value("${spring.application.name}") private String appName; - @Autowired - private UnicastProcessor> listener; - - private String commandId = ThreadLocalRandom.current().nextInt() + ""; - private Long data = ThreadLocalRandom.current().nextLong(); + private final String commandId = ThreadLocalRandom.current().nextInt() + ""; + private final Long data = ThreadLocalRandom.current().nextLong(); @Test void commandShouldArrive() { Command command = new Command<>(COMMAND_NAME, commandId, data); gateway.sendCommand(command, appName).subscribe(); + Sinks.Many> listener = Sinks.many().unicast().onBackpressureBuffer(); - StepVerifier.create(listener.next()).assertNext(cmd -> { + StepVerifier.create(listener.asFlux().next()).assertNext(cmd -> { assertThat(cmd).extracting(Command::getCommandId, Command::getData, Command::getName) - .containsExactly(commandId, data, COMMAND_NAME); + .containsExactly(commandId, data, COMMAND_NAME); }).verifyComplete(); } @@ -57,34 +55,33 @@ void commandShouldArrive() { void shouldReceiveResponse() { final Mono reply = gateway.requestReply(new AsyncQuery<>("double", 42), appName, Integer.class); StepVerifier.create(reply.timeout(Duration.ofSeconds(15))) - .expectNext(42*2) - .verifyComplete(); + .expectNext(42 * 2) + .verifyComplete(); } - @SpringBootApplication @EnableDirectAsyncGateway @EnableMessageListeners - static class App{ + static class App { public static void main(String[] args) { SpringApplication.run(App.class, args); } @Bean - public HandlerRegistry registry(UnicastProcessor> listener) { + public HandlerRegistry registry(Sinks.Many> listener) { return HandlerRegistry.register() - .serveQuery("double", rqt -> just(rqt*2), Long.class) - .handleCommand(COMMAND_NAME, handle(listener), Long.class); + .serveQuery("double", rqt -> just(rqt * 2), Long.class) + .handleCommand(COMMAND_NAME, handle(listener), Long.class); } @Bean - public UnicastProcessor> listener() { - return UnicastProcessor.create(); + public Sinks.Many> listener() { + return Sinks.many().unicast().onBackpressureBuffer(); } - private DomainCommandHandler handle(UnicastProcessor> listener) { + private DomainCommandHandler handle(Sinks.Many> listener) { return command -> { - listener.onNext(command); + listener.emitNext(command, Sinks.EmitFailureHandler.FAIL_FAST); return empty(); }; } diff --git a/acceptance/async-tests/src/test/java/org/reactivecommons/test/SimpleEventNotificationTest.java b/acceptance/async-tests/src/test/java/org/reactivecommons/test/SimpleEventNotificationTest.java index e8c8c313..ff5c7949 100644 --- a/acceptance/async-tests/src/test/java/org/reactivecommons/test/SimpleEventNotificationTest.java +++ b/acceptance/async-tests/src/test/java/org/reactivecommons/test/SimpleEventNotificationTest.java @@ -12,7 +12,7 @@ import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.context.annotation.Bean; -import reactor.core.publisher.UnicastProcessor; +import reactor.core.publisher.Sinks; import reactor.test.StepVerifier; import java.util.concurrent.ThreadLocalRandom; @@ -30,17 +30,15 @@ class SimpleEventNotificationTest { @Autowired private DomainEventBus eventBus; - @Autowired - private UnicastProcessor> listener; - - private String eventId = ThreadLocalRandom.current().nextInt() + ""; - private Long data = ThreadLocalRandom.current().nextLong(); + private final String eventId = ThreadLocalRandom.current().nextInt() + ""; + private final Long data = ThreadLocalRandom.current().nextLong(); @Test void shouldReceiveEvent() throws InterruptedException { DomainEvent event = new DomainEvent<>(EVENT_NAME, eventId, data); + Sinks.Many> listener = Sinks.many().unicast().onBackpressureBuffer(); from(eventBus.emit(event)).subscribe(); - StepVerifier.create(listener.take(1)).assertNext(evt -> + StepVerifier.create(listener.asFlux().take(1)).assertNext(evt -> assertThat(evt).extracting(DomainEvent::getName, DomainEvent::getEventId, DomainEvent::getData) .containsExactly(EVENT_NAME, eventId, data) ).verifyComplete(); @@ -56,20 +54,20 @@ public static void main(String[] args) { } @Bean - public HandlerRegistry registry(UnicastProcessor> listener) { + public HandlerRegistry registry(Sinks.Many> listener) { return HandlerRegistry.register() .serveQuery("double", rqt -> just(rqt * 2), Long.class) .listenEvent(EVENT_NAME, handle(listener), Long.class); } @Bean - public UnicastProcessor> listener() { - return UnicastProcessor.create(); + public Sinks.Many> listener() { + return Sinks.many().unicast().onBackpressureBuffer(); } - private DomainEventHandler handle(UnicastProcessor> listener) { + private DomainEventHandler handle(Sinks.Many> listener) { return command -> { - listener.onNext(command); + listener.emitNext(command, Sinks.EmitFailureHandler.FAIL_FAST); return empty(); }; } diff --git a/acceptance/async-tests/src/test/java/org/reactivecommons/test/perf/BlockingCommandHandlePerfTest.java b/acceptance/async-tests/src/test/java/org/reactivecommons/test/perf/BlockingCommandHandlePerfTest.java index df853929..f146ee9a 100644 --- a/acceptance/async-tests/src/test/java/org/reactivecommons/test/perf/BlockingCommandHandlePerfTest.java +++ b/acceptance/async-tests/src/test/java/org/reactivecommons/test/perf/BlockingCommandHandlePerfTest.java @@ -14,7 +14,7 @@ import org.springframework.boot.test.context.SpringBootTest; import org.springframework.context.annotation.Bean; import reactor.core.publisher.Flux; -import reactor.core.publisher.UnicastProcessor; +import reactor.core.publisher.Sinks; import reactor.test.StepVerifier; import java.time.Duration; @@ -36,14 +36,13 @@ class BlockingCommandHandlePerfTest { @Value("${spring.application.name}") private String appName; - @Autowired - private UnicastProcessor> listener; - - private String commandId = ThreadLocalRandom.current().nextInt() + ""; - private Long data = ThreadLocalRandom.current().nextLong(); + private final String commandId = ThreadLocalRandom.current().nextInt() + ""; + private final Long data = ThreadLocalRandom.current().nextLong(); @Test void commandShouldBeHandledInParallel() throws InterruptedException { + Sinks.Many> listener = Sinks.many().unicast().onBackpressureBuffer(); + Flux.range(0, 12).flatMap(i -> { Command command = new Command<>(COMMAND_NAME, commandId + 1, data + 1); return gateway.sendCommand(command, appName); @@ -51,13 +50,13 @@ void commandShouldBeHandledInParallel() throws InterruptedException { final long init = System.currentTimeMillis(); - final Flux> results = listener.take(12).collectList() + final Flux> results = listener.asFlux().take(12).collectList() .timeout(Duration.ofMillis(1500)) .flatMapMany(Flux::fromIterable); StepVerifier.create(results).assertNext(cmd -> { - assertThat(cmd.getName()).isEqualTo(COMMAND_NAME); - }) + assertThat(cmd.getName()).isEqualTo(COMMAND_NAME); + }) .expectNextCount(11) .verifyComplete(); @@ -79,30 +78,25 @@ public static void main(String[] args) { } @Bean - public HandlerRegistry registry(UnicastProcessor> listener) { + public HandlerRegistry registry(Sinks.Many> listener) { return HandlerRegistry.register() .handleCommand(COMMAND_NAME, handle(listener), Long.class); } @Bean - public UnicastProcessor> listener() { - return UnicastProcessor.create(); + public Sinks.Many> listener() { + return Sinks.many().unicast().onBackpressureBuffer(); } - private DomainCommandHandler handle(UnicastProcessor> listener) { - return command -> { - return fromRunnable(() -> { -// out.println("Received at: " + System.currentTimeMillis()/1000); - try { -// out.println("internal: " + Thread.currentThread().getName()); - TimeUnit.MILLISECONDS.sleep(750); -// out.println("Handled at: " + System.currentTimeMillis()/1000); - listener.onNext(command); - } catch (InterruptedException e) { - } - listener.onNext(command); - }); - }; + private DomainCommandHandler handle(Sinks.Many> listener) { + return command -> fromRunnable(() -> { + try { + TimeUnit.MILLISECONDS.sleep(750); + listener.emitNext(command, Sinks.EmitFailureHandler.FAIL_FAST); + } catch (InterruptedException ignored) { + } + listener.emitNext(command, Sinks.EmitFailureHandler.FAIL_FAST); + }); } } } diff --git a/acceptance/async-tests/src/test/java/org/reactivecommons/test/perf/ParallelOnBlockingInSubscriptionTimeTest.java b/acceptance/async-tests/src/test/java/org/reactivecommons/test/perf/ParallelOnBlockingInSubscriptionTimeTest.java index 510c38f6..c2d00722 100644 --- a/acceptance/async-tests/src/test/java/org/reactivecommons/test/perf/ParallelOnBlockingInSubscriptionTimeTest.java +++ b/acceptance/async-tests/src/test/java/org/reactivecommons/test/perf/ParallelOnBlockingInSubscriptionTimeTest.java @@ -15,7 +15,7 @@ import org.springframework.boot.test.context.SpringBootTest; import org.springframework.context.annotation.Bean; import reactor.core.publisher.Flux; -import reactor.core.publisher.UnicastProcessor; +import reactor.core.publisher.Sinks; import reactor.test.StepVerifier; import java.time.Duration; @@ -37,15 +37,13 @@ class ParallelOnBlockingInSubscriptionTimeTest { @Value("${spring.application.name}") private String appName; - @Autowired - private UnicastProcessor> listener; - - private String commandId = ThreadLocalRandom.current().nextInt() + ""; - private Long data = ThreadLocalRandom.current().nextLong(); + private final String commandId = ThreadLocalRandom.current().nextInt() + ""; + private final Long data = ThreadLocalRandom.current().nextLong(); @Test @Disabled - public void commandShouldBeHandledInParallel() throws InterruptedException { + void commandShouldBeHandledInParallel() throws InterruptedException { + Sinks.Many> listener = Sinks.many().unicast().onBackpressureBuffer(); Flux.range(0, 12).flatMap(i -> { Command command = new Command<>(COMMAND_NAME, commandId + 1, data + 1); return gateway.sendCommand(command, appName); @@ -53,13 +51,13 @@ public void commandShouldBeHandledInParallel() throws InterruptedException { final long init = System.currentTimeMillis(); - final Flux> results = listener.take(12).collectList() + final Flux> results = listener.asFlux().take(12).collectList() .timeout(Duration.ofMillis(1500)) .flatMapMany(Flux::fromIterable); StepVerifier.create(results).assertNext(cmd -> { - assertThat(cmd.getName()).isEqualTo(COMMAND_NAME); - }) + assertThat(cmd.getName()).isEqualTo(COMMAND_NAME); + }) .expectNextCount(11) .verifyComplete(); @@ -81,27 +79,24 @@ public static void main(String[] args) { } @Bean - public HandlerRegistry registry(UnicastProcessor> listener) { + public HandlerRegistry registry(Sinks.Many> listener) { return HandlerRegistry.register() .handleCommand(COMMAND_NAME, handle(listener), Long.class); } @Bean - public UnicastProcessor> listener() { - return UnicastProcessor.create(); + public Sinks.Many> listener() { + return Sinks.many().unicast().onBackpressureBuffer(); } - private DomainCommandHandler handle(UnicastProcessor> listener) { + private DomainCommandHandler handle(Sinks.Many> listener) { return command -> { -// out.println("Received at: " + System.currentTimeMillis()/1000); try { -// out.println("internal: " + Thread.currentThread().getName()); TimeUnit.MILLISECONDS.sleep(750); -// out.println("Handled at: " + System.currentTimeMillis()/1000); - listener.onNext(command); + listener.emitNext(command, Sinks.EmitFailureHandler.FAIL_FAST); } catch (InterruptedException e) { } - listener.onNext(command); + listener.emitNext(command, Sinks.EmitFailureHandler.FAIL_FAST); return empty(); }; } diff --git a/acceptance/async-tests/src/test/java/org/reactivecommons/test/perf/SimpleCommandHandlePerfTest.java b/acceptance/async-tests/src/test/java/org/reactivecommons/test/perf/SimpleCommandHandlePerfTest.java index f5c37146..582bf059 100644 --- a/acceptance/async-tests/src/test/java/org/reactivecommons/test/perf/SimpleCommandHandlePerfTest.java +++ b/acceptance/async-tests/src/test/java/org/reactivecommons/test/perf/SimpleCommandHandlePerfTest.java @@ -15,7 +15,7 @@ import org.springframework.boot.test.context.SpringBootTest; import org.springframework.context.annotation.Bean; import reactor.core.publisher.Flux; -import reactor.core.publisher.UnicastProcessor; +import reactor.core.publisher.Sinks; import reactor.test.StepVerifier; import java.time.Duration; @@ -36,15 +36,13 @@ class SimpleCommandHandlePerfTest { @Value("${spring.application.name}") private String appName; - @Autowired - private UnicastProcessor> listener; - - private String commandId = ThreadLocalRandom.current().nextInt() + ""; - private Long data = ThreadLocalRandom.current().nextLong(); + private final String commandId = ThreadLocalRandom.current().nextInt() + ""; + private final Long data = ThreadLocalRandom.current().nextLong(); @Test @Disabled - public void commandShouldBeHandledInParallel() { + void commandShouldBeHandledInParallel() { + Sinks.Many> listener = Sinks.many().unicast().onBackpressureBuffer(); Flux.range(0, 30).flatMap(i -> { Command command = new Command<>(COMMAND_NAME, commandId + 1, data + 1); return gateway.sendCommand(command, appName); @@ -52,13 +50,13 @@ public void commandShouldBeHandledInParallel() { final long init = System.currentTimeMillis(); - final Flux> results = listener.take(30).collectList() + final Flux> results = listener.asFlux().take(30).collectList() .timeout(Duration.ofMillis(3500)) .flatMapMany(Flux::fromIterable); StepVerifier.create(results).assertNext(cmd -> { - assertThat(cmd.getName()).isEqualTo(COMMAND_NAME); - }) + assertThat(cmd.getName()).isEqualTo(COMMAND_NAME); + }) .expectNextCount(29) .verifyComplete(); @@ -78,23 +76,23 @@ public static void main(String[] args) { } @Bean - public HandlerRegistry registry(UnicastProcessor> listener) { + public HandlerRegistry registry(Sinks.Many> listener) { return HandlerRegistry.register() .handleCommand(COMMAND_NAME, handle(listener), Long.class); } @Bean - public UnicastProcessor> listener() { - return UnicastProcessor.create(); + public Sinks.Many> listener() { + return Sinks.many().unicast().onBackpressureBuffer(); } - private DomainCommandHandler handle(UnicastProcessor> listener) { + private DomainCommandHandler handle(Sinks.Many> listener) { return command -> { out.println("Received at: " + System.currentTimeMillis() / 1000); out.println("Received in: " + Thread.currentThread().getName()); return delay(Duration.ofMillis(750)).doOnNext(i -> { out.println("Handled at: " + System.currentTimeMillis() / 1000); - listener.onNext(command); + listener.emitNext(command, Sinks.EmitFailureHandler.FAIL_FAST); }).then(); }; } diff --git a/async/async-commons-api/src/main/java/org/reactivecommons/async/api/DirectAsyncGateway.java b/async/async-commons-api/src/main/java/org/reactivecommons/async/api/DirectAsyncGateway.java index 661b5349..ee48e05e 100644 --- a/async/async-commons-api/src/main/java/org/reactivecommons/async/api/DirectAsyncGateway.java +++ b/async/async-commons-api/src/main/java/org/reactivecommons/async/api/DirectAsyncGateway.java @@ -5,7 +5,7 @@ import reactor.core.publisher.Mono; public interface DirectAsyncGateway { - public static final String DELAYED = "rc-delay"; + String DELAYED = "rc-delay"; Mono sendCommand(Command command, String targetName); diff --git a/async/async-commons-api/src/main/java/org/reactivecommons/async/api/HandlerRegistry.java b/async/async-commons-api/src/main/java/org/reactivecommons/async/api/HandlerRegistry.java index 67ae2a08..f97d2e8c 100644 --- a/async/async-commons-api/src/main/java/org/reactivecommons/async/api/HandlerRegistry.java +++ b/async/async-commons-api/src/main/java/org/reactivecommons/async/api/HandlerRegistry.java @@ -22,7 +22,7 @@ @Getter @NoArgsConstructor(access = AccessLevel.PACKAGE) -public class HandlerRegistry { +public final class HandlerRegistry { public static final String DEFAULT_DOMAIN = "app"; private final Map>> domainEventListeners = new ConcurrentHashMap<>(); private final List> dynamicEventHandlers = new CopyOnWriteArrayList<>(); @@ -37,7 +37,8 @@ public static HandlerRegistry register() { return instance; } - public HandlerRegistry listenDomainEvent(String domain, String eventName, DomainEventHandler handler, Class eventClass) { + public HandlerRegistry listenDomainEvent(String domain, String eventName, DomainEventHandler handler, + Class eventClass) { domainEventListeners.computeIfAbsent(domain, ignored -> new CopyOnWriteArrayList<>()) .add(new RegisteredEventListener<>(eventName, handler, eventClass)); return this; @@ -61,7 +62,8 @@ public HandlerRegistry listenCloudEvent(String eventName, CloudEventHandler hand return this; } - public HandlerRegistry listenNotificationEvent(String eventName, DomainEventHandler handler, Class eventClass) { + public HandlerRegistry listenNotificationEvent(String eventName, DomainEventHandler handler, + Class eventClass) { eventNotificationListener.add(new RegisteredEventListener<>(eventName, handler, eventClass)); return this; } @@ -71,7 +73,8 @@ public HandlerRegistry listenNotificationCloudEvent(String eventName, CloudEvent return this; } - public HandlerRegistry handleDynamicEvents(String eventNamePattern, DomainEventHandler handler, Class eventClass) { + public HandlerRegistry handleDynamicEvents(String eventNamePattern, DomainEventHandler handler, + Class eventClass) { dynamicEventHandlers.add(new RegisteredEventListener<>(eventNamePattern, handler, eventClass)); return this; } @@ -92,7 +95,9 @@ public HandlerRegistry handleCloudEventCommand(String commandName, CloudCommandH } public HandlerRegistry serveQuery(String resource, QueryHandler handler, Class queryClass) { - handlers.add(new RegisteredQueryHandler<>(resource, (ignored, message) -> handler.handle(message), queryClass)); + handlers.add(new RegisteredQueryHandler<>(resource, (ignored, message) -> + handler.handle(message), queryClass + )); return this; } @@ -102,7 +107,9 @@ public HandlerRegistry serveQuery(String resource, QueryHandlerDelegate HandlerRegistry serveCloudEventQuery(String resource, QueryHandler handler) { - handlers.add(new RegisteredQueryHandler<>(resource, (ignored, message) -> handler.handle(message), CloudEvent.class)); + handlers.add(new RegisteredQueryHandler<>(resource, (ignored, message) -> + handler.handle(message), CloudEvent.class + )); return this; } diff --git a/async/async-commons-api/src/test/java/org/reactivecommons/async/api/HandlerRegistryTest.java b/async/async-commons-api/src/test/java/org/reactivecommons/async/api/HandlerRegistryTest.java index 5cda7121..af3db020 100644 --- a/async/async-commons-api/src/test/java/org/reactivecommons/async/api/HandlerRegistryTest.java +++ b/async/async-commons-api/src/test/java/org/reactivecommons/async/api/HandlerRegistryTest.java @@ -34,7 +34,9 @@ void shouldListenDomainEvent() { assertThat(registry.getDomainEventListeners().get(domain)) .anySatisfy(registered -> assertThat(registered) - .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass, RegisteredEventListener::getHandler) + .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass, + RegisteredEventListener::getHandler + ) .containsExactly(name, SomeDataClass.class, eventHandler)).hasSize(1); } @@ -46,7 +48,9 @@ void shouldListenDomainCloudEvent() { assertThat(registry.getDomainEventListeners().get(domain)) .anySatisfy(registered -> assertThat(registered) - .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass, RegisteredEventListener::getHandler) + .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass, + RegisteredEventListener::getHandler + ) .containsExactly(name, CloudEvent.class, eventHandler)).hasSize(1); } @@ -58,7 +62,9 @@ void shouldListenEvent() { assertThat(registry.getDomainEventListeners().get(DEFAULT_DOMAIN)) .anySatisfy(registered -> assertThat(registered) - .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass, RegisteredEventListener::getHandler) + .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass, + RegisteredEventListener::getHandler + ) .containsExactly(name, SomeDataClass.class, eventHandler)).hasSize(1); } @@ -70,7 +76,9 @@ void shouldListenCloudEvent() { assertThat(registry.getDomainEventListeners().get(DEFAULT_DOMAIN)) .anySatisfy(registered -> assertThat(registered) - .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass, RegisteredEventListener::getHandler) + .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass, + RegisteredEventListener::getHandler + ) .containsExactly(name, CloudEvent.class, eventHandler)).hasSize(1); } @@ -109,13 +117,15 @@ void shouldRegisterNotificationCloudEventListener() { @Test @SuppressWarnings("unchecked") - public void listenEvent() { + void listenEvent() { SomeDomainEventHandler handler = mock(SomeDomainEventHandler.class); registry.listenEvent(name, handler, SomeDataClass.class); assertThat(registry.getDomainEventListeners().get(DEFAULT_DOMAIN)) .anySatisfy(registered -> assertThat(registered) - .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass, RegisteredEventListener::getHandler) + .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass, + RegisteredEventListener::getHandler + ) .containsExactly(name, SomeDataClass.class, handler)).hasSize(1); } @@ -127,7 +137,9 @@ void shouldListenDynamicEvent() { assertThat(registry.getDynamicEventHandlers()) .anySatisfy(registered -> assertThat(registered) - .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass, RegisteredEventListener::getHandler) + .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass, + RegisteredEventListener::getHandler + ) .containsExactly(name, SomeDataClass.class, eventHandler)).hasSize(1); } @@ -139,7 +151,9 @@ void shouldListenDynamicCloudEvent() { assertThat(registry.getDynamicEventHandlers()) .anySatisfy(registered -> assertThat(registered) - .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass, RegisteredEventListener::getHandler) + .extracting(RegisteredEventListener::getPath, RegisteredEventListener::getInputClass, + RegisteredEventListener::getHandler + ) .containsExactly(name, CloudEvent.class, eventHandler)).hasSize(1); } @@ -151,7 +165,9 @@ void handleDomainCommand() { assertThat(registry.getCommandHandlers()) .anySatisfy(registered -> assertThat(registered) - .extracting(RegisteredCommandHandler::getPath, RegisteredCommandHandler::getInputClass, RegisteredCommandHandler::getHandler) + .extracting(RegisteredCommandHandler::getPath, RegisteredCommandHandler::getInputClass, + RegisteredCommandHandler::getHandler + ) .containsExactly(name, SomeDataClass.class, handler)).hasSize(1); } @@ -163,7 +179,9 @@ void handleCloudEventCommand() { assertThat(registry.getCommandHandlers()) .anySatisfy(registered -> assertThat(registered) - .extracting(RegisteredCommandHandler::getPath, RegisteredCommandHandler::getInputClass, RegisteredCommandHandler::getHandler) + .extracting(RegisteredCommandHandler::getPath, RegisteredCommandHandler::getInputClass, + RegisteredCommandHandler::getHandler + ) .containsExactly(name, CloudEvent.class, cloudCommandHandler)).hasSize(1); } @@ -206,7 +224,8 @@ void serveQueryWithTypeInference() { assertThat(registry.getHandlers()).anySatisfy(registered -> { assertThat(registered).extracting(RegisteredQueryHandler::getPath, RegisteredQueryHandler::getQueryClass) .containsExactly(name, SomeDataClass.class); - assertThat(registered).extracting(RegisteredQueryHandler::getHandler).isInstanceOf(QueryHandlerDelegate.class); + assertThat(registered).extracting(RegisteredQueryHandler::getHandler) + .isInstanceOf(QueryHandlerDelegate.class); }).hasSize(1); } @@ -278,7 +297,6 @@ public Mono handle(CloudEvent message) { } } - @Data private static class SomeDataClass { private String someProp1; diff --git a/async/async-commons/src/main/java/org/reactivecommons/async/commons/CommandExecutor.java b/async/async-commons/src/main/java/org/reactivecommons/async/commons/CommandExecutor.java index 4ceb6641..b0e36641 100644 --- a/async/async-commons/src/main/java/org/reactivecommons/async/commons/CommandExecutor.java +++ b/async/async-commons/src/main/java/org/reactivecommons/async/commons/CommandExecutor.java @@ -1,13 +1,13 @@ package org.reactivecommons.async.commons; -import lombok.AllArgsConstructor; +import lombok.RequiredArgsConstructor; import org.reactivecommons.async.api.handlers.CommandHandler; import org.reactivecommons.async.commons.communications.Message; import reactor.core.publisher.Mono; import java.util.function.Function; -@AllArgsConstructor +@RequiredArgsConstructor public class CommandExecutor { private final CommandHandler eventHandler; private final Function converter; diff --git a/async/async-commons/src/main/java/org/reactivecommons/async/commons/DLQDiscardNotifier.java b/async/async-commons/src/main/java/org/reactivecommons/async/commons/DLQDiscardNotifier.java index 78510323..4c5e59fe 100644 --- a/async/async-commons/src/main/java/org/reactivecommons/async/commons/DLQDiscardNotifier.java +++ b/async/async-commons/src/main/java/org/reactivecommons/async/commons/DLQDiscardNotifier.java @@ -3,8 +3,8 @@ import com.fasterxml.jackson.databind.JsonNode; import io.cloudevents.CloudEvent; import io.cloudevents.core.builder.CloudEventBuilder; -import lombok.AllArgsConstructor; import lombok.Data; +import lombok.RequiredArgsConstructor; import lombok.extern.java.Log; import org.reactivecommons.api.domain.DomainEvent; import org.reactivecommons.api.domain.DomainEventBus; @@ -19,7 +19,7 @@ import static org.reactivecommons.async.commons.converters.json.JacksonMessageConverter.APPLICATION_CLOUD_EVENT_JSON; @Log -@AllArgsConstructor +@RequiredArgsConstructor public class DLQDiscardNotifier implements DiscardNotifier { private final DomainEventBus eventBus; private final MessageConverter messageConverter; diff --git a/async/async-commons/src/main/java/org/reactivecommons/async/commons/EventExecutor.java b/async/async-commons/src/main/java/org/reactivecommons/async/commons/EventExecutor.java index fef94e99..39657bf6 100644 --- a/async/async-commons/src/main/java/org/reactivecommons/async/commons/EventExecutor.java +++ b/async/async-commons/src/main/java/org/reactivecommons/async/commons/EventExecutor.java @@ -1,13 +1,13 @@ package org.reactivecommons.async.commons; -import lombok.AllArgsConstructor; +import lombok.RequiredArgsConstructor; import org.reactivecommons.async.api.handlers.EventHandler; import org.reactivecommons.async.commons.communications.Message; import reactor.core.publisher.Mono; import java.util.function.Function; -@AllArgsConstructor +@RequiredArgsConstructor public class EventExecutor { private final EventHandler eventHandler; private final Function converter; diff --git a/async/async-commons/src/main/java/org/reactivecommons/async/commons/FallbackStrategy.java b/async/async-commons/src/main/java/org/reactivecommons/async/commons/FallbackStrategy.java index 3648f67e..d30525fa 100644 --- a/async/async-commons/src/main/java/org/reactivecommons/async/commons/FallbackStrategy.java +++ b/async/async-commons/src/main/java/org/reactivecommons/async/commons/FallbackStrategy.java @@ -1,12 +1,12 @@ package org.reactivecommons.async.commons; +import lombok.RequiredArgsConstructor; + +@RequiredArgsConstructor public enum FallbackStrategy { FAST_RETRY("ATTENTION!! Fast retry message to same Queue: %s"), DEFINITIVE_DISCARD("ATTENTION!! DEFINITIVE DISCARD!! of the message: %s"), RETRY_DLQ("ATTENTION!! Sending message to Retry DLQ: %s"); public final String message; - FallbackStrategy(String message){ - this.message = message; - } } diff --git a/async/async-commons/src/main/java/org/reactivecommons/async/commons/HandlerResolver.java b/async/async-commons/src/main/java/org/reactivecommons/async/commons/HandlerResolver.java index 17bbe0c4..562461ac 100644 --- a/async/async-commons/src/main/java/org/reactivecommons/async/commons/HandlerResolver.java +++ b/async/async-commons/src/main/java/org/reactivecommons/async/commons/HandlerResolver.java @@ -80,10 +80,7 @@ public void addQueryHandler(RegisteredQueryHandler handler) { } private Function getMatchHandler(Map handlers) { - return name -> { - String matched = matcher.match(handlers.keySet(), name); - return handlers.get(matched); - }; + return name -> handlers.get(matcher.match(handlers.keySet(), name)); } } diff --git a/async/async-commons/src/main/java/org/reactivecommons/async/commons/HandlerResolverBuilder.java b/async/async-commons/src/main/java/org/reactivecommons/async/commons/HandlerResolverBuilder.java index 62ec7479..cceb6625 100644 --- a/async/async-commons/src/main/java/org/reactivecommons/async/commons/HandlerResolverBuilder.java +++ b/async/async-commons/src/main/java/org/reactivecommons/async/commons/HandlerResolverBuilder.java @@ -16,33 +16,35 @@ import static org.reactivecommons.async.api.HandlerRegistry.DEFAULT_DOMAIN; -@NoArgsConstructor(access = AccessLevel.PRIVATE) @Log -public class HandlerResolverBuilder { +@NoArgsConstructor(access = AccessLevel.PRIVATE) +public final class HandlerResolverBuilder { - public static HandlerResolver buildResolver(String domain, - Map registries, + public static HandlerResolver buildResolver(String domain, Map registries, final DefaultCommandHandler defaultCommandHandler) { if (DEFAULT_DOMAIN.equals(domain)) { final ConcurrentMap> queryHandlers = registries .values().stream() .flatMap(r -> r.getHandlers().stream()) - .collect(ConcurrentHashMap::new, (map, handler) -> map.put(handler.getPath(), handler), - ConcurrentHashMap::putAll); + .collect(ConcurrentHashMap::new, (map, handler) + -> map.put(handler.getPath(), handler), ConcurrentHashMap::putAll + ); final ConcurrentMap> commandHandlers = registries .values().stream() .flatMap(r -> r.getCommandHandlers().stream()) - .collect(ConcurrentHashMap::new, (map, handler) -> map.put(handler.getPath(), handler), - ConcurrentHashMap::putAll); + .collect(ConcurrentHashMap::new, (map, handler) + -> map.put(handler.getPath(), handler), ConcurrentHashMap::putAll + ); final ConcurrentMap> eventNotificationListener = registries .values() .stream() .flatMap(r -> r.getEventNotificationListener().stream()) - .collect(ConcurrentHashMap::new, (map, handler) -> map.put(handler.getPath(), handler), - ConcurrentHashMap::putAll); + .collect(ConcurrentHashMap::new, (map, handler) + -> map.put(handler.getPath(), handler), ConcurrentHashMap::putAll + ); final ConcurrentMap> eventsToBind = getEventsToBind(domain, registries); @@ -79,9 +81,8 @@ public RegisteredCommandHandler getCommandHandler(String path) { }; } - private static ConcurrentMap> getEventHandlersWithDynamics(String domain, - Map registries) { + private static ConcurrentMap> getEventHandlersWithDynamics( + String domain, Map registries) { // event handlers and dynamic handlers return registries .values().stream() @@ -91,8 +92,9 @@ public RegisteredCommandHandler getCommandHandler(String path) { } return Stream.empty(); }) - .collect(ConcurrentHashMap::new, (map, handler) -> map.put(handler.getPath(), handler), - ConcurrentHashMap::putAll); + .collect(ConcurrentHashMap::new, (map, handler) + -> map.put(handler.getPath(), handler), ConcurrentHashMap::putAll + ); } private static Stream> getDynamics(String domain, HandlerRegistry r) { @@ -102,8 +104,8 @@ public RegisteredCommandHandler getCommandHandler(String path) { return Stream.of(); } - private static ConcurrentMap> getEventsToBind(String domain, Map registries) { + private static ConcurrentMap> getEventsToBind( + String domain, Map registries) { return registries .values().stream() .flatMap(r -> { @@ -112,7 +114,8 @@ public RegisteredCommandHandler getCommandHandler(String path) { } return Stream.empty(); }) - .collect(ConcurrentHashMap::new, (map, handler) -> map.put(handler.getPath(), handler), - ConcurrentHashMap::putAll); + .collect(ConcurrentHashMap::new, (map, handler) + -> map.put(handler.getPath(), handler), ConcurrentHashMap::putAll + ); } } diff --git a/async/async-commons/src/main/java/org/reactivecommons/async/commons/Headers.java b/async/async-commons/src/main/java/org/reactivecommons/async/commons/Headers.java index 05bbe553..4058b4ba 100644 --- a/async/async-commons/src/main/java/org/reactivecommons/async/commons/Headers.java +++ b/async/async-commons/src/main/java/org/reactivecommons/async/commons/Headers.java @@ -1,5 +1,10 @@ package org.reactivecommons.async.commons; + +import lombok.AccessLevel; +import lombok.NoArgsConstructor; + +@NoArgsConstructor(access = AccessLevel.PRIVATE) public final class Headers { public static final String REPLY_ID = "x-reply_id"; @@ -8,9 +13,4 @@ public final class Headers { public static final String SERVED_QUERY_ID = "x-serveQuery-id"; public static final String SOURCE_APPLICATION = "sourceApplication"; public static final String REPLY_TIMEOUT_MILLIS = "x-reply-timeout-millis"; - - - private Headers() { - } - } diff --git a/async/async-commons/src/main/java/org/reactivecommons/async/commons/config/BrokerConfig.java b/async/async-commons/src/main/java/org/reactivecommons/async/commons/config/BrokerConfig.java index e3bd99f9..9ea2fbe6 100644 --- a/async/async-commons/src/main/java/org/reactivecommons/async/commons/config/BrokerConfig.java +++ b/async/async-commons/src/main/java/org/reactivecommons/async/commons/config/BrokerConfig.java @@ -1,13 +1,15 @@ package org.reactivecommons.async.commons.config; import lombok.Getter; +import lombok.RequiredArgsConstructor; import java.time.Duration; import java.util.UUID; @Getter +@RequiredArgsConstructor public class BrokerConfig { - private final String routingKey = UUID.randomUUID().toString().replaceAll("-", ""); + private final String routingKey = UUID.randomUUID().toString().replace("-", ""); private final boolean persistentQueries; private final boolean persistentCommands; private final boolean persistentEvents; @@ -20,11 +22,4 @@ public BrokerConfig() { this.replyTimeout = Duration.ofSeconds(15); } - public BrokerConfig(boolean persistentQueries, boolean persistentCommands, boolean persistentEvents, Duration replyTimeout) { - this.persistentQueries = persistentQueries; - this.persistentCommands = persistentCommands; - this.persistentEvents = persistentEvents; - this.replyTimeout = replyTimeout; - } - } diff --git a/async/async-commons/src/main/java/org/reactivecommons/async/commons/converters/json/CloudEventBuilderExt.java b/async/async-commons/src/main/java/org/reactivecommons/async/commons/converters/json/CloudEventBuilderExt.java index 8ceb7b0d..311f5137 100644 --- a/async/async-commons/src/main/java/org/reactivecommons/async/commons/converters/json/CloudEventBuilderExt.java +++ b/async/async-commons/src/main/java/org/reactivecommons/async/commons/converters/json/CloudEventBuilderExt.java @@ -3,13 +3,14 @@ import com.fasterxml.jackson.databind.ObjectMapper; import io.cloudevents.CloudEvent; import io.cloudevents.CloudEventData; +import lombok.AccessLevel; +import lombok.AllArgsConstructor; import lombok.SneakyThrows; -import lombok.experimental.UtilityClass; import java.util.Objects; -@UtilityClass -public class CloudEventBuilderExt { +@AllArgsConstructor(access = AccessLevel.PRIVATE) +public final class CloudEventBuilderExt { private static final ObjectMapper mapper = new ObjectMapper(); @SneakyThrows diff --git a/async/async-commons/src/main/java/org/reactivecommons/async/commons/ext/CustomReporter.java b/async/async-commons/src/main/java/org/reactivecommons/async/commons/ext/CustomReporter.java index 2a94f7aa..ef4bbbea 100644 --- a/async/async-commons/src/main/java/org/reactivecommons/async/commons/ext/CustomReporter.java +++ b/async/async-commons/src/main/java/org/reactivecommons/async/commons/ext/CustomReporter.java @@ -13,23 +13,27 @@ public interface CustomReporter { String QUERY_CLASS = "org.reactivecommons.async.api.AsyncQuery"; default Mono reportError(Throwable ex, Message rawMessage, Object message, boolean redelivered) { - switch (message.getClass().getName()){ - case COMMAND_CLASS: - return reportError(ex, rawMessage, (Command) message, redelivered); - case EVENT_CLASS: - return reportError(ex, rawMessage, (DomainEvent) message, redelivered); - case QUERY_CLASS: - return reportError(ex, rawMessage, (AsyncQuery) message, redelivered); - default: - return Mono.empty(); - } + var name = message.getClass().getName(); + return Mono.just(name) + .filter(COMMAND_CLASS::equals) + .flatMap(n -> reportError(ex, rawMessage, (Command) message, redelivered)) + .switchIfEmpty(Mono.just(name) + .filter(EVENT_CLASS::equals) + .flatMap(n -> reportError(ex, rawMessage, (DomainEvent) message, redelivered)) + .switchIfEmpty(Mono.just(name) + .filter(QUERY_CLASS::equals) + .flatMap(n -> reportError(ex, rawMessage, (AsyncQuery) message, redelivered)) + ) + ); } default void reportMetric(String type, String handlerPath, Long duration, boolean success) { } Mono reportError(Throwable ex, Message rawMessage, Command message, boolean redelivered); + Mono reportError(Throwable ex, Message rawMessage, DomainEvent message, boolean redelivered); + Mono reportError(Throwable ex, Message rawMessage, AsyncQuery message, boolean redelivered); } diff --git a/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/ArrayUtils.java b/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/ArrayUtils.java index 009678f4..0a67edec 100644 --- a/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/ArrayUtils.java +++ b/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/ArrayUtils.java @@ -1,11 +1,14 @@ package org.reactivecommons.async.commons.utils; +import lombok.AccessLevel; +import lombok.AllArgsConstructor; + import java.util.ArrayList; import java.util.Arrays; -public class ArrayUtils { - private ArrayUtils(){} +@AllArgsConstructor(access = AccessLevel.PRIVATE) +public final class ArrayUtils { public static Object[] prefixArray(E head, E[] tail) { final ArrayList objects = new ArrayList<>(1 + tail.length); diff --git a/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/LoggerSubscriber.java b/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/LoggerSubscriber.java index 0d2aff9c..26168a9e 100644 --- a/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/LoggerSubscriber.java +++ b/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/LoggerSubscriber.java @@ -1,5 +1,6 @@ package org.reactivecommons.async.commons.utils; +import lombok.RequiredArgsConstructor; import lombok.extern.java.Log; import reactor.core.publisher.BaseSubscriber; import reactor.core.publisher.SignalType; @@ -10,6 +11,7 @@ @Log +@RequiredArgsConstructor public class LoggerSubscriber extends BaseSubscriber { private final String flowName; @@ -18,10 +20,6 @@ public class LoggerSubscriber extends BaseSubscriber { private static final String ON_CANCEL_MSG = "%s: ##On Cancel Hook!!"; private static final String ON_FINALLY_MSG = "%s: ##On Finally Hook! Signal type: %s"; - public LoggerSubscriber(String flowName) { - this.flowName = flowName; - } - @Override protected void hookOnComplete() { log.warning(format(ON_COMPLETE_MSG)); diff --git a/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/NameGenerator.java b/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/NameGenerator.java index 40013ec8..259c3d25 100644 --- a/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/NameGenerator.java +++ b/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/NameGenerator.java @@ -1,10 +1,14 @@ package org.reactivecommons.async.commons.utils; +import lombok.AccessLevel; +import lombok.AllArgsConstructor; + import java.nio.ByteBuffer; import java.util.Base64; import java.util.UUID; -public class NameGenerator { +@AllArgsConstructor(access = AccessLevel.PRIVATE) +public final class NameGenerator { public static String fromNameWithSuffix(String appName, String suffix) { if (suffix != null && !suffix.isEmpty()) { @@ -27,7 +31,7 @@ private static String generateName(String applicationName, String suffix) { bb.putLong(uuid.getMostSignificantBits()) .putLong(uuid.getLeastSignificantBits()); // Convert to base64 and remove trailing = - String realSuffix = suffix != null && !"".equals(suffix) ? suffix + "." : ""; + String realSuffix = suffix != null && !suffix.isEmpty() ? suffix + "." : ""; return applicationName + "." + realSuffix + encodeToUrlSafeString(bb.array()) .replace("=", ""); } diff --git a/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/resolver/HandlerResolverUtil.java b/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/resolver/HandlerResolverUtil.java index 47e0e11b..39a4e876 100644 --- a/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/resolver/HandlerResolverUtil.java +++ b/async/async-commons/src/main/java/org/reactivecommons/async/commons/utils/resolver/HandlerResolverUtil.java @@ -1,6 +1,7 @@ package org.reactivecommons.async.commons.utils.resolver; -import lombok.experimental.UtilityClass; +import lombok.AccessLevel; +import lombok.AllArgsConstructor; import org.reactivecommons.async.api.HandlerRegistry; import org.reactivecommons.async.api.handlers.CommandHandler; import org.reactivecommons.async.api.handlers.registered.RegisteredCommandHandler; @@ -15,8 +16,8 @@ import static org.reactivecommons.async.api.HandlerRegistry.DEFAULT_DOMAIN; -@UtilityClass -public class HandlerResolverUtil { +@AllArgsConstructor(access = AccessLevel.PRIVATE) +public final class HandlerResolverUtil { public static HandlerResolver fromHandlerRegistries(Collection registries, CommandHandler defaultHandler) { diff --git a/async/async-commons/src/test/java/org/reactivecommons/async/commons/reply/ReactiveReplyRouterTest.java b/async/async-commons/src/test/java/org/reactivecommons/async/commons/reply/ReactiveReplyRouterTest.java index 4878fcb1..c43d8ab7 100644 --- a/async/async-commons/src/test/java/org/reactivecommons/async/commons/reply/ReactiveReplyRouterTest.java +++ b/async/async-commons/src/test/java/org/reactivecommons/async/commons/reply/ReactiveReplyRouterTest.java @@ -14,7 +14,7 @@ class ReactiveReplyRouterTest { private final ReactiveReplyRouter replyRouter = new ReactiveReplyRouter(); @Test - void shouldRouteReply(){ + void shouldRouteReply() { final String uuid = UUID.randomUUID().toString(); final Mono registered = replyRouter.register(uuid); @@ -28,18 +28,18 @@ void shouldRouteReply(){ } @Test - void shouldRouteEmptyResponse(){ + void shouldRouteEmptyResponse() { final String uuid = UUID.randomUUID().toString(); final Mono registered = replyRouter.register(uuid); replyRouter.routeEmpty(uuid); StepVerifier.create(registered) - .verifyComplete(); + .verifyComplete(); } @Test - void shouldDeRegisterProcessor(){ + void shouldDeRegisterProcessor() { final String uuid = UUID.randomUUID().toString(); final Mono registered = replyRouter.register(uuid); @@ -47,7 +47,7 @@ void shouldDeRegisterProcessor(){ replyRouter.routeEmpty(uuid); StepVerifier.create(registered.timeout(Duration.ofSeconds(1))) - .expectTimeout(Duration.ofSeconds(3)).verify(); + .expectTimeout(Duration.ofSeconds(3)).verify(); } } diff --git a/async/async-commons/src/test/java/org/reactivecommons/async/commons/utils/matcher/KeyMatcherPerformanceManualTest.java b/async/async-commons/src/test/java/org/reactivecommons/async/commons/utils/matcher/KeyMatcherPerformanceManualTest.java index c07c9ea9..d1e7870c 100755 --- a/async/async-commons/src/test/java/org/reactivecommons/async/commons/utils/matcher/KeyMatcherPerformanceManualTest.java +++ b/async/async-commons/src/test/java/org/reactivecommons/async/commons/utils/matcher/KeyMatcherPerformanceManualTest.java @@ -13,6 +13,7 @@ import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Set; import java.util.stream.Collectors; @@ -21,7 +22,7 @@ class KeyMatcherPerformanceManualTest { Map candidates = new HashMap<>(); - private KeyMatcher keyMatcher = new KeyMatcher(); + private final KeyMatcher keyMatcher = new KeyMatcher(); private List testList; private List testResultList; @@ -29,7 +30,7 @@ class KeyMatcherPerformanceManualTest { @BeforeEach public void init() { ClassLoader classLoader = getClass().getClassLoader(); - File file = new File(classLoader.getResource("candidateNamesForMatching.txt").getFile()); + File file = new File(Objects.requireNonNull(classLoader.getResource("candidateNamesForMatching.txt")).getFile()); try { Set names = new HashSet<>(Files .readAllLines(Paths.get(file.getAbsolutePath()))); diff --git a/async/async-commons/src/test/java/org/reactivecommons/async/commons/utils/matcher/KeyMatcherPerformanceWildcardTest.java b/async/async-commons/src/test/java/org/reactivecommons/async/commons/utils/matcher/KeyMatcherPerformanceWildcardTest.java index b607233d..eec4cb12 100755 --- a/async/async-commons/src/test/java/org/reactivecommons/async/commons/utils/matcher/KeyMatcherPerformanceWildcardTest.java +++ b/async/async-commons/src/test/java/org/reactivecommons/async/commons/utils/matcher/KeyMatcherPerformanceWildcardTest.java @@ -13,6 +13,7 @@ import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Set; import java.util.stream.Collectors; @@ -21,7 +22,7 @@ class KeyMatcherPerformanceWildcardTest { Map candidates = new HashMap<>(); - private KeyMatcher keyMatcher = new KeyMatcher(); + private final KeyMatcher keyMatcher = new KeyMatcher(); private List testList; private List testResultList; @@ -29,8 +30,12 @@ class KeyMatcherPerformanceWildcardTest { @BeforeEach public void setUp() { ClassLoader classLoader = getClass().getClassLoader(); - File file = new File(classLoader.getResource("wildcard_names_for_matching.txt").getFile()); - File file2 = new File(classLoader.getResource("concrete_names_for_matching.txt").getFile()); + var file = new File(Objects.requireNonNull( + classLoader.getResource("wildcard_names_for_matching.txt")).getFile() + ); + var file2 = new File( + Objects.requireNonNull(classLoader.getResource("concrete_names_for_matching.txt")).getFile() + ); try { Set names = new HashSet<>(Files .readAllLines(Paths.get(file.getAbsolutePath()))); diff --git a/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/KafkaDomainEventBus.java b/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/KafkaDomainEventBus.java index cbd5a09b..b31f4a78 100644 --- a/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/KafkaDomainEventBus.java +++ b/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/KafkaDomainEventBus.java @@ -1,13 +1,13 @@ package org.reactivecommons.async.kafka; import io.cloudevents.CloudEvent; -import lombok.AllArgsConstructor; +import lombok.RequiredArgsConstructor; import org.reactivecommons.api.domain.DomainEvent; import org.reactivecommons.api.domain.DomainEventBus; import org.reactivecommons.async.kafka.communications.ReactiveMessageSender; import org.reactivestreams.Publisher; -@AllArgsConstructor +@RequiredArgsConstructor public class KafkaDomainEventBus implements DomainEventBus { public static final String NOT_IMPLEMENTED_YET = "Not implemented yet"; private final ReactiveMessageSender sender; diff --git a/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/KafkaMessage.java b/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/KafkaMessage.java index 7c5092de..bafda174 100644 --- a/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/KafkaMessage.java +++ b/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/KafkaMessage.java @@ -29,18 +29,18 @@ public String getContentType() { } } - public static KafkaMessage fromDelivery(ReceiverRecord record) { - return new KafkaMessage(record.value(), createMessageProps(record)); + public static KafkaMessage fromDelivery(ReceiverRecord receiverRecord) { + return new KafkaMessage(receiverRecord.value(), createMessageProps(receiverRecord)); } - private static Properties createMessageProps(ReceiverRecord record) { - Map headers = parseHeaders(record.headers()); + private static Properties createMessageProps(ReceiverRecord receiverRecord) { + Map headers = parseHeaders(receiverRecord.headers()); final KafkaMessageProperties properties = new KafkaMessageProperties(); properties.setHeaders(headers); - properties.setKey(record.key()); - properties.setTopic(record.topic()); - properties.setContentLength(record.value().length); + properties.setKey(receiverRecord.key()); + properties.setTopic(receiverRecord.topic()); + properties.setContentLength(receiverRecord.value().length); return properties; } diff --git a/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/communications/ReactiveMessageListener.java b/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/communications/ReactiveMessageListener.java index 9cdf1921..e46f4b85 100644 --- a/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/communications/ReactiveMessageListener.java +++ b/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/communications/ReactiveMessageListener.java @@ -1,6 +1,6 @@ package org.reactivecommons.async.kafka.communications; -import lombok.AllArgsConstructor; +import lombok.RequiredArgsConstructor; import reactor.core.publisher.Flux; import reactor.kafka.receiver.KafkaReceiver; import reactor.kafka.receiver.ReceiverOptions; @@ -13,7 +13,7 @@ import static org.apache.kafka.clients.consumer.ConsumerConfig.MAX_POLL_RECORDS_CONFIG; -@AllArgsConstructor +@RequiredArgsConstructor public class ReactiveMessageListener { private final ReceiverOptions receiverOptions; diff --git a/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/communications/ReactiveMessageSender.java b/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/communications/ReactiveMessageSender.java index 7e13d05a..99d97608 100644 --- a/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/communications/ReactiveMessageSender.java +++ b/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/communications/ReactiveMessageSender.java @@ -26,13 +26,18 @@ public class ReactiveMessageSender { private final ConcurrentHashMap> confirmations = new ConcurrentHashMap<>(); - private final CopyOnWriteArrayList>> fluxSinks = new CopyOnWriteArrayList<>(); + private final CopyOnWriteArrayList>> fluxSinks = + new CopyOnWriteArrayList<>(); private final AtomicLong counter = new AtomicLong(); - private final ExecutorService executorServiceConfirm = Executors.newFixedThreadPool(13, r -> new Thread(r, "KMessageSender1-" + counter.getAndIncrement())); - private final ExecutorService executorServiceEmit = Executors.newFixedThreadPool(13, r -> new Thread(r, "KMessageSender2-" + counter.getAndIncrement())); + private final ExecutorService executorServiceConfirm = Executors.newFixedThreadPool(13, r -> + new Thread(r, "KMessageSender1-" + counter.getAndIncrement()) + ); + private final ExecutorService executorServiceEmit = Executors.newFixedThreadPool(13, r -> + new Thread(r, "KMessageSender2-" + counter.getAndIncrement()) + ); - private final int senderCount = 4; + private static final int SENDER_COUNT = 4; private final MessageConverter messageConverter; private final TopologyCreator topologyCreator; @@ -41,7 +46,7 @@ public ReactiveMessageSender(KafkaSender sender, MessageConverte TopologyCreator topologyCreator) { this.messageConverter = messageConverter; this.topologyCreator = topologyCreator; - for (int i = 0; i < senderCount; ++i) { + for (int i = 0; i < SENDER_COUNT; ++i) { Flux> source = Flux.create(fluxSinks::add); sender.send(source) .doOnNext(this::confirm) @@ -51,9 +56,10 @@ public ReactiveMessageSender(KafkaSender sender, MessageConverte public Mono send(V message) { return Mono.create(sink -> { - SenderRecord record = createRecord(message); - confirmations.put(record.key(), sink); - executorServiceEmit.submit(() -> fluxSinks.get((int) (System.currentTimeMillis() % senderCount)).next(record)); + SenderRecord senderRecord = createRecord(message); + confirmations.put(senderRecord.key(), sink); + executorServiceEmit.submit(() -> fluxSinks.get((int) (System.currentTimeMillis() % SENDER_COUNT)) + .next(senderRecord)); }); } @@ -72,8 +78,8 @@ private void confirm(SenderResult result) { private SenderRecord createRecord(V object) { KafkaMessage message = (KafkaMessage) messageConverter.toMessage(object); - ProducerRecord record = createProducerRecord(message); - return SenderRecord.create(record, message.getProperties().getKey()); // TODO: Review for Request-Reply + ProducerRecord producerRecord = createProducerRecord(message); + return SenderRecord.create(producerRecord, message.getProperties().getKey()); // TODO: Review for Request-Reply } @SneakyThrows diff --git a/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/communications/topology/TopologyCreator.java b/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/communications/topology/TopologyCreator.java index f7217197..7b5e4a8c 100644 --- a/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/communications/topology/TopologyCreator.java +++ b/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/communications/topology/TopologyCreator.java @@ -38,16 +38,15 @@ public Map getTopics() { } public Mono createTopics(List topics) { - TopicCustomization.TopicCustomizationBuilder defaultBuilder = TopicCustomization.builder() - .partitions(-1) - .replicationFactor((short) -1); - return Flux.fromIterable(topics) .map(topic -> { if (customizations.getTopics().containsKey(topic)) { return customizations.getTopics().get(topic); } - return defaultBuilder.topic(topic).build(); + return TopicCustomization.builder() + .partitions(-1) + .replicationFactor((short) -1) + .topic(topic).build(); }) .map(this::toNewTopic) .flatMap(this::createTopic) diff --git a/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/listeners/GenericMessageListener.java b/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/listeners/GenericMessageListener.java index da47e237..fc20596a 100644 --- a/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/listeners/GenericMessageListener.java +++ b/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/listeners/GenericMessageListener.java @@ -28,7 +28,6 @@ @Log public abstract class GenericMessageListener { - public static final int DEFAULT_RETRIES = 10; private final ConcurrentHashMap>> handlers = new ConcurrentHashMap<>(); private final ReactiveMessageListener messageListener; private final Scheduler scheduler = Schedulers.newParallel(getClass().getSimpleName(), 12); @@ -46,9 +45,10 @@ public abstract class GenericMessageListener { private final CustomReporter customReporter; private volatile Flux> messageFlux; - public GenericMessageListener(ReactiveMessageListener listener, boolean useDLQ, boolean createTopology, - long maxRetries, long retryDelay, DiscardNotifier discardNotifier, - String objectType, CustomReporter customReporter, String groupId, List topics) { + protected GenericMessageListener(ReactiveMessageListener listener, boolean useDLQ, boolean createTopology, + long maxRetries, long retryDelay, DiscardNotifier discardNotifier, + String objectType, CustomReporter customReporter, String groupId, + List topics) { this.groupId = groupId; this.topics = topics; this.messageListener = listener; @@ -71,8 +71,8 @@ protected Mono setUpBindings(TopologyCreator creator) { public void startListener(TopologyCreator creator) { log.log(Level.INFO, "Using max concurrency {0}, in receiver for topics: {1}", - new Object[]{messageListener.getMaxConcurrency(), topics}); + if (useDLQ) { log.log(Level.INFO, "ATTENTION! Using DLQ Strategy for retries with {0} + 1 Max Retries configured!", new Object[]{maxRetries}); @@ -103,7 +103,7 @@ private Flux> consumeFaultTolerant(Flux { final Instant init = Instant.now(); return handle(msj, init) - .doOnSuccess(record -> record.receiverOffset().acknowledge()) + .doOnSuccess(r -> r.receiverOffset().acknowledge()) .onErrorResume(err -> requeueOrAck(msj, err, init)); }, messageListener.getMaxConcurrency()); } @@ -187,7 +187,9 @@ private void doLogExecution(String executorPath, long timeElapsed) { protected void logError(Throwable err, ReceiverRecord msj, FallbackStrategy strategy) { String messageID = msj.key(); try { - log.log(Level.SEVERE, format("Error encounter while processing message %s: %s", messageID, err.toString()), err); + log.log(Level.SEVERE, + format("Error encounter while processing message %s: %s", messageID, err.toString()), err + ); log.warning(format("Message %s Headers: %s", messageID, msj.headers().toString())); log.warning(format("Message %s Body: %s", messageID, new String(msj.value()))); } catch (Exception e) { diff --git a/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/KafkaDirectAsyncGatewayTest.java b/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/KafkaDirectAsyncGatewayTest.java index d1229f58..9bdcc3ef 100644 --- a/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/KafkaDirectAsyncGatewayTest.java +++ b/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/KafkaDirectAsyncGatewayTest.java @@ -29,20 +29,42 @@ class KafkaDirectAsyncGatewayTest { @Test void allMethodsAreNotImplemented() { - assertThrows(UnsupportedOperationException.class, () -> directAsyncGateway.sendCommand(cloudEvent, targetName)); - assertThrows(UnsupportedOperationException.class, () -> directAsyncGateway.sendCommand(cloudEvent, targetName, domain)); - assertThrows(UnsupportedOperationException.class, () -> directAsyncGateway.sendCommand(cloudEvent, targetName, delay)); - assertThrows(UnsupportedOperationException.class, () -> directAsyncGateway.sendCommand(cloudEvent, targetName, delay, domain)); - assertThrows(UnsupportedOperationException.class, () -> directAsyncGateway.sendCommand(command, targetName)); - assertThrows(UnsupportedOperationException.class, () -> directAsyncGateway.sendCommand(command, targetName, domain)); - assertThrows(UnsupportedOperationException.class, () -> directAsyncGateway.sendCommand(command, targetName, delay)); - assertThrows(UnsupportedOperationException.class, () -> directAsyncGateway.sendCommand(command, targetName, delay, domain)); - - assertThrows(UnsupportedOperationException.class, () -> directAsyncGateway.requestReply(cloudEvent, targetName, CloudEvent.class)); - assertThrows(UnsupportedOperationException.class, () -> directAsyncGateway.requestReply(cloudEvent, targetName, CloudEvent.class, domain)); - assertThrows(UnsupportedOperationException.class, () -> directAsyncGateway.requestReply(query, targetName, CloudEvent.class)); - assertThrows(UnsupportedOperationException.class, () -> directAsyncGateway.requestReply(query, targetName, CloudEvent.class, domain)); - + assertThrows(UnsupportedOperationException.class, + () -> directAsyncGateway.sendCommand(cloudEvent, targetName) + ); + assertThrows(UnsupportedOperationException.class, + () -> directAsyncGateway.sendCommand(cloudEvent, targetName, domain) + ); + assertThrows(UnsupportedOperationException.class, + () -> directAsyncGateway.sendCommand(cloudEvent, targetName, delay) + ); + assertThrows(UnsupportedOperationException.class, + () -> directAsyncGateway.sendCommand(cloudEvent, targetName, delay, domain) + ); + assertThrows(UnsupportedOperationException.class, + () -> directAsyncGateway.sendCommand(command, targetName) + ); + assertThrows(UnsupportedOperationException.class, + () -> directAsyncGateway.sendCommand(command, targetName, domain) + ); + assertThrows(UnsupportedOperationException.class, + () -> directAsyncGateway.sendCommand(command, targetName, delay) + ); + assertThrows(UnsupportedOperationException.class, + () -> directAsyncGateway.sendCommand(command, targetName, delay, domain) + ); + assertThrows(UnsupportedOperationException.class, + () -> directAsyncGateway.requestReply(cloudEvent, targetName, CloudEvent.class) + ); + assertThrows(UnsupportedOperationException.class, + () -> directAsyncGateway.requestReply(cloudEvent, targetName, CloudEvent.class, domain) + ); + assertThrows(UnsupportedOperationException.class, + () -> directAsyncGateway.requestReply(query, targetName, CloudEvent.class) + ); + assertThrows(UnsupportedOperationException.class, + () -> directAsyncGateway.requestReply(query, targetName, CloudEvent.class, domain) + ); assertThrows(UnsupportedOperationException.class, () -> directAsyncGateway.reply(targetName, from)); } } diff --git a/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/KafkaMessageTest.java b/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/KafkaMessageTest.java index 4ac1dec5..3433ebb4 100644 --- a/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/KafkaMessageTest.java +++ b/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/KafkaMessageTest.java @@ -16,19 +16,19 @@ class KafkaMessageTest { @Mock - private ReceiverRecord record; + private ReceiverRecord receiverRecord; @Test void shouldParse() { // Arrange RecordHeaders headers = new RecordHeaders(); headers.add("content-type", "application/json".getBytes()); - when(record.value()).thenReturn("value".getBytes()); - when(record.key()).thenReturn("key"); - when(record.topic()).thenReturn("topic"); - when(record.headers()).thenReturn(headers); + when(receiverRecord.value()).thenReturn("value".getBytes()); + when(receiverRecord.key()).thenReturn("key"); + when(receiverRecord.topic()).thenReturn("topic"); + when(receiverRecord.headers()).thenReturn(headers); // Act - Message message = KafkaMessage.fromDelivery(record); + Message message = KafkaMessage.fromDelivery(receiverRecord); // Assert assertEquals("key", message.getProperties().getKey()); assertEquals("topic", message.getProperties().getTopic()); @@ -41,12 +41,12 @@ void shouldParse() { void shouldParseWhenNoContentType() { // Arrange RecordHeaders headers = new RecordHeaders(); - when(record.value()).thenReturn("value".getBytes()); - when(record.key()).thenReturn("key"); - when(record.topic()).thenReturn("topic"); - when(record.headers()).thenReturn(headers); + when(receiverRecord.value()).thenReturn("value".getBytes()); + when(receiverRecord.key()).thenReturn("key"); + when(receiverRecord.topic()).thenReturn("topic"); + when(receiverRecord.headers()).thenReturn(headers); // Act - Message message = KafkaMessage.fromDelivery(record); + Message message = KafkaMessage.fromDelivery(receiverRecord); // Assert assertEquals("key", message.getProperties().getKey()); assertEquals("topic", message.getProperties().getTopic()); diff --git a/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/communications/topology/KafkaCustomizationsTest.java b/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/communications/topology/KafkaCustomizationsTest.java index 2f8dcb41..83b3f30b 100644 --- a/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/communications/topology/KafkaCustomizationsTest.java +++ b/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/communications/topology/KafkaCustomizationsTest.java @@ -9,7 +9,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; -public class KafkaCustomizationsTest { +class KafkaCustomizationsTest { private KafkaCustomizations customizations; diff --git a/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/listeners/GenericMessageListenerTest.java b/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/listeners/GenericMessageListenerTest.java index 83dbdeb9..014a7aca 100644 --- a/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/listeners/GenericMessageListenerTest.java +++ b/async/async-kafka/src/test/java/org/reactivecommons/async/kafka/listeners/GenericMessageListenerTest.java @@ -30,7 +30,7 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@SuppressWarnings({"rawtypes", "unchecked"}) +@SuppressWarnings("unchecked") @ExtendWith(MockitoExtension.class) class GenericMessageListenerTest { @@ -64,14 +64,14 @@ SampleListener setup(Function> handler) { @Test void shouldStartListener() { // Arrange - ReceiverRecord record = mock(ReceiverRecord.class); - when(record.topic()).thenReturn("topic"); - when(record.value()).thenReturn("message".getBytes(StandardCharsets.UTF_8)); + ReceiverRecord receiverRecord = mock(ReceiverRecord.class); + when(receiverRecord.topic()).thenReturn("topic"); + when(receiverRecord.value()).thenReturn("message".getBytes(StandardCharsets.UTF_8)); Headers header = new RecordHeaders().add("contentType", "application/json".getBytes(StandardCharsets.UTF_8)); - when(record.headers()).thenReturn(header); - when(record.key()).thenReturn("key"); + when(receiverRecord.headers()).thenReturn(header); + when(receiverRecord.key()).thenReturn("key"); - Flux> flux = Flux.just(record); + Flux> flux = Flux.just(receiverRecord); when(receiver.listen(anyString(), any(List.class))).thenReturn(flux); when(receiver.getMaxConcurrency()).thenReturn(1); when(topologyCreator.createTopics(any(List.class))).thenReturn(Mono.empty()); @@ -89,7 +89,6 @@ void shouldStartListener() { verify(topologyCreator, times(1)).createTopics(any(List.class)); } - public static class SampleListener extends GenericMessageListener { private final Function> handler; diff --git a/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/DynamicRegistryImp.java b/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/DynamicRegistryImp.java index 8e22c31a..fcca072a 100644 --- a/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/DynamicRegistryImp.java +++ b/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/DynamicRegistryImp.java @@ -32,8 +32,9 @@ public Mono listenEvent(String eventName, DomainEventHandler fn, Cl @Override public void serveQuery(String resource, QueryHandler handler, Class queryClass) { - resolver.addQueryHandler(new RegisteredQueryHandler<>(resource, (ignored, message) -> handler.handle(message) - , queryClass)); + resolver.addQueryHandler(new RegisteredQueryHandler<>(resource, + (ignored, message) -> handler.handle(message), queryClass) + ); } @Override diff --git a/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/communications/ReactiveMessageSender.java b/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/communications/ReactiveMessageSender.java index eb35f00c..3ae9856a 100644 --- a/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/communications/ReactiveMessageSender.java +++ b/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/communications/ReactiveMessageSender.java @@ -1,6 +1,7 @@ package org.reactivecommons.async.rabbit.communications; import com.rabbitmq.client.AMQP; +import lombok.Getter; import org.reactivecommons.async.commons.communications.Message; import org.reactivecommons.async.commons.converters.MessageConverter; import org.reactivecommons.async.commons.exceptions.SendFailureNoAckException; @@ -26,58 +27,72 @@ import static org.reactivecommons.async.commons.Headers.SOURCE_APPLICATION; public class ReactiveMessageSender { + @Getter private final Sender sender; private final String sourceApplication; private final MessageConverter messageConverter; + @Getter private final TopologyCreator topologyCreator; - private final int numberOfSenderSubscriptions = 4; + private static final int NUMBER_OF_SENDER_SUBSCRIPTIONS = 4; private final CopyOnWriteArrayList> fluxSinkConfirm = new CopyOnWriteArrayList<>(); private volatile FluxSink fluxSinkNoConfirm; private final AtomicLong counter = new AtomicLong(); - private final ExecutorService executorService = Executors.newFixedThreadPool(13, r -> new Thread(r, "RMessageSender1-" + counter.getAndIncrement())); - private final ExecutorService executorService2 = Executors.newFixedThreadPool(13, r -> new Thread(r, "RMessageSender2-" + counter.getAndIncrement())); + private final ExecutorService executorService = Executors.newFixedThreadPool( + 13, r -> new Thread(r, "RMessageSender1-" + counter.getAndIncrement()) + ); + private final ExecutorService executorService2 = Executors.newFixedThreadPool( + 13, r -> new Thread(r, "RMessageSender2-" + counter.getAndIncrement()) + ); - public ReactiveMessageSender(Sender sender, String sourceApplication, MessageConverter messageConverter, TopologyCreator topologyCreator) { + public ReactiveMessageSender(Sender sender, String sourceApplication, + MessageConverter messageConverter, TopologyCreator topologyCreator) { this.sender = sender; this.sourceApplication = sourceApplication; this.messageConverter = messageConverter; this.topologyCreator = topologyCreator; - for (int i = 0; i < numberOfSenderSubscriptions; ++i) { + for (int i = 0; i < NUMBER_OF_SENDER_SUBSCRIPTIONS; ++i) { final Flux messageSource = Flux.create(fluxSinkConfirm::add); sender.sendWithTypedPublishConfirms(messageSource) .doOnNext((OutboundMessageResult outboundMessageResult) -> { - final Consumer ackNotifier = outboundMessageResult.getOutboundMessage().getAckNotifier(); - executorService.submit(() -> ackNotifier.accept(outboundMessageResult.isAck())); - }).subscribe(); + final Consumer ackNotifier = outboundMessageResult.getOutboundMessage().getAckNotifier(); + executorService.submit(() -> ackNotifier.accept(outboundMessageResult.isAck())); + }).subscribe(); } - final Flux messageSourceNoConfirm = Flux.create(fluxSink -> { - this.fluxSinkNoConfirm = fluxSink; - }); + final Flux messageSourceNoConfirm = Flux.create(fluxSink -> + this.fluxSinkNoConfirm = fluxSink + ); sender.send(messageSourceNoConfirm).subscribe(); } - public Mono sendWithConfirm(T message, String exchange, String routingKey, Map headers, boolean persistent) { + public Mono sendWithConfirm(T message, String exchange, String routingKey, + Map headers, boolean persistent) { return Mono.create(monoSink -> { Consumer notifier = new AckNotifier(monoSink); - final MyOutboundMessage outboundMessage = toOutboundMessage(message, exchange, routingKey, headers, notifier, persistent); - executorService2.submit(() -> fluxSinkConfirm.get((int) (System.currentTimeMillis() % numberOfSenderSubscriptions)).next(outboundMessage)); + final MyOutboundMessage outboundMessage = toOutboundMessage( + message, exchange, routingKey, headers, notifier, persistent + ); + executorService2.submit(() -> fluxSinkConfirm.get( + (int) (System.currentTimeMillis() % NUMBER_OF_SENDER_SUBSCRIPTIONS)).next(outboundMessage) + ); }); } - public Mono sendNoConfirm(T message, String exchange, String routingKey, Map headers, boolean persistent) { + public Mono sendNoConfirm(T message, String exchange, String routingKey, + Map headers, boolean persistent) { fluxSinkNoConfirm.next(toOutboundMessage(message, exchange, routingKey, headers, persistent)); return Mono.empty(); } - public Flux sendWithConfirmBatch(Flux messages, String exchange, String routingKey, Map headers, boolean persistent) { + public Flux sendWithConfirmBatch(Flux messages, String exchange, String routingKey, + Map headers, boolean persistent) { return messages.map(message -> toOutboundMessage(message, exchange, routingKey, headers, persistent)) .as(sender::sendWithPublishConfirms) .flatMap(result -> result.isAck() ? @@ -95,7 +110,7 @@ public AckNotifier(MonoSink monoSink) { @Override public void accept(Boolean ack) { - if (ack) { + if (Boolean.TRUE.equals(ack)) { monoSink.success(); } else { monoSink.error(new SendFailureNoAckException("No ACK when sending message")); @@ -104,33 +119,37 @@ public void accept(Boolean ack) { } + @Getter static class MyOutboundMessage extends OutboundMessage { private final Consumer ackNotifier; - public MyOutboundMessage(String exchange, String routingKey, AMQP.BasicProperties properties, byte[] body, Consumer ackNotifier) { + public MyOutboundMessage( + String exchange, String routingKey, AMQP.BasicProperties properties, + byte[] body, Consumer ackNotifier + ) { super(exchange, routingKey, properties, body); this.ackNotifier = ackNotifier; } - - public Consumer getAckNotifier() { - return ackNotifier; - } } - private MyOutboundMessage toOutboundMessage(T object, String exchange, String routingKey, Map headers, Consumer ackNotifier, boolean persistent) { + private MyOutboundMessage toOutboundMessage(T object, String exchange, + String routingKey, Map headers, + Consumer ackNotifier, boolean persistent) { final Message message = messageConverter.toMessage(object); final AMQP.BasicProperties props = buildMessageProperties(message, headers, persistent); return new MyOutboundMessage(exchange, routingKey, props, message.getBody(), ackNotifier); } - private OutboundMessage toOutboundMessage(T object, String exchange, String routingKey, Map headers, boolean persistent) { + private OutboundMessage toOutboundMessage(T object, String exchange, String routingKey, + Map headers, boolean persistent) { final Message message = messageConverter.toMessage(object); final AMQP.BasicProperties props = buildMessageProperties(message, headers, persistent); return new OutboundMessage(exchange, routingKey, props, message.getBody()); } - private AMQP.BasicProperties buildMessageProperties(Message message, Map headers, boolean persistent) { + private AMQP.BasicProperties buildMessageProperties(Message message, Map headers, + boolean persistent) { final Message.Properties properties = message.getProperties(); final Map baseHeaders = new HashMap<>(properties.getHeaders()); baseHeaders.putAll(headers); @@ -148,13 +167,5 @@ private AMQP.BasicProperties buildMessageProperties(Message message, Map unbind(BindingSpecification binding) { .onErrorMap(TopologyDefException::new); } - public Mono declareDLQ(String originQueue, String retryTarget, int retryTime, Optional maxLengthBytesOpt) { + public Mono declareDLQ(String originQueue, String retryTarget, int retryTime, + Optional maxLengthBytesOpt) { final Map args = new HashMap<>(); args.put("x-dead-letter-exchange", retryTarget); args.put("x-message-ttl", retryTime); @@ -55,7 +56,8 @@ public Mono declareDLQ(String originQueue, String retryTar return declare(specification); } - public Mono declareQueue(String name, String dlqExchange, Optional maxLengthBytesOpt) { + public Mono declareQueue(String name, String dlqExchange, + Optional maxLengthBytesOpt) { return declareQueue(name, dlqExchange, maxLengthBytesOpt, Optional.empty()); } diff --git a/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationCommandListener.java b/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationCommandListener.java index 2e04b22f..42316813 100644 --- a/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationCommandListener.java +++ b/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationCommandListener.java @@ -64,13 +64,25 @@ public ApplicationCommandListener(ReactiveMessageListener listener, } protected Mono setUpBindings(TopologyCreator creator) { - final Mono declareExchange = creator.declare(ExchangeSpecification.exchange(directExchange).durable(true).type("direct")); + final Mono declareExchange = creator.declare( + ExchangeSpecification.exchange(directExchange).durable(true).type("direct") + ); if (withDLQRetry) { - final Mono declareExchangeDLQ = creator.declare(ExchangeSpecification.exchange(directExchange + DQL).durable(true).type("direct")); - final Mono declareQueue = creator.declareQueue(queueName, directExchange + DQL, maxLengthBytes); - final Mono declareDLQ = creator.declareDLQ(queueName, directExchange, retryDelay, maxLengthBytes); - final Mono binding = creator.bind(BindingSpecification.binding(directExchange, queueName, queueName)); - final Mono bindingDLQ = creator.bind(BindingSpecification.binding(directExchange + DQL, queueName, queueName + DQL)); + final Mono declareExchangeDLQ = creator.declare( + ExchangeSpecification.exchange(directExchange + DQL).durable(true).type("direct") + ); + final Mono declareQueue = creator.declareQueue( + queueName, directExchange + DQL, maxLengthBytes + ); + final Mono declareDLQ = creator.declareDLQ( + queueName, directExchange, retryDelay, maxLengthBytes + ); + final Mono binding = creator.bind(BindingSpecification.binding( + directExchange, queueName, queueName) + ); + final Mono bindingDLQ = creator.bind( + BindingSpecification.binding(directExchange + DQL, queueName, queueName + DQL) + ); return declareExchange.then(declareExchangeDLQ) .then(declareDLQ) .then(declareQueue) @@ -80,7 +92,9 @@ protected Mono setUpBindings(TopologyCreator creator) { .then(); } else { final Mono declareQueue = creator.declareQueue(queueName, maxLengthBytes); - final Mono binding = creator.bind(BindingSpecification.binding(directExchange, queueName, queueName)); + final Mono binding = creator.bind( + BindingSpecification.binding(directExchange, queueName, queueName) + ); return declareExchange.then(declareQueue).then(binding).then(declareDelayedTopology(creator)).then(); } } @@ -88,8 +102,12 @@ protected Mono setUpBindings(TopologyCreator creator) { private Mono declareDelayedTopology(TopologyCreator creator) { if (delayedCommands) { String delayedQueue = queueName + "-delayed"; - final Mono declareQueue = creator.declareQueue(delayedQueue, directExchange, maxLengthBytes, Optional.of(queueName)); - final Mono binding = creator.bind(BindingSpecification.binding(directExchange, delayedQueue, delayedQueue)); + final Mono declareQueue = creator.declareQueue( + delayedQueue, directExchange, maxLengthBytes, Optional.of(queueName) + ); + final Mono binding = creator.bind( + BindingSpecification.binding(directExchange, delayedQueue, delayedQueue) + ); return declareQueue.then(binding).then(); } return Mono.empty(); @@ -109,9 +127,8 @@ protected String getExecutorPath(AcknowledgableDelivery msj) { JsonNode jsonNode = messageConverter.readValue(rabbitMessage, JsonNode.class); if (jsonNode.get(COMMAND_ID) != null) { return jsonNode.get(NAME).asText(); - } else { - return jsonNode.get(TYPE).asText(); } + return jsonNode.get(TYPE).asText(); } @Override diff --git a/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationEventListener.java b/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationEventListener.java index 73f1e481..11cfd5ba 100644 --- a/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationEventListener.java +++ b/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationEventListener.java @@ -61,18 +61,42 @@ public ApplicationEventListener(ReactiveMessageListener receiver, } protected Mono setUpBindings(TopologyCreator creator) { - final Mono declareExchange = creator.declare(ExchangeSpecification.exchange(eventsExchange).durable(true).type("topic")); - final Flux bindings = fromIterable(resolver.getEventListeners()).flatMap(listener -> creator.bind(BindingSpecification.binding(eventsExchange, listener.getPath(), queueName))); + final Mono declareExchange = creator.declare( + ExchangeSpecification.exchange(eventsExchange).durable(true).type("topic") + ); + final Flux bindings = fromIterable(resolver.getEventListeners()) + .flatMap(listener -> creator.bind( + BindingSpecification.binding(eventsExchange, listener.getPath(), queueName) + )); if (withDLQRetry) { final String eventsDLQExchangeName = format("%s.%s.DLQ", appName, eventsExchange); final String retryExchangeName = format("%s.%s", appName, eventsExchange); - final Mono retryExchange = creator.declare(ExchangeSpecification.exchange(retryExchangeName).durable(true).type("topic")); - final Mono declareExchangeDLQ = creator.declare(ExchangeSpecification.exchange(eventsDLQExchangeName).durable(true).type("topic")); - final Mono declareDLQ = creator.declareDLQ(queueName, retryExchangeName, retryDelay, maxLengthBytes); - final Mono declareQueue = creator.declareQueue(queueName, eventsDLQExchangeName, maxLengthBytes); - final Mono bindingDLQ = creator.bind(BindingSpecification.binding(eventsDLQExchangeName, "#", queueName + ".DLQ")); - final Mono retryBinding = creator.bind(BindingSpecification.binding(retryExchangeName, "#", queueName)); - return declareExchange.then(retryExchange).then(declareExchangeDLQ).then(declareQueue).then(declareDLQ).thenMany(bindings).then(bindingDLQ).then(retryBinding).then(); + final Mono retryExchange = creator.declare( + ExchangeSpecification.exchange(retryExchangeName).durable(true).type("topic") + ); + final Mono declareExchangeDLQ = creator.declare( + ExchangeSpecification.exchange(eventsDLQExchangeName).durable(true).type("topic") + ); + final Mono declareDLQ = creator.declareDLQ( + queueName, retryExchangeName, retryDelay, maxLengthBytes + ); + final Mono declareQueue = creator.declareQueue( + queueName, eventsDLQExchangeName, maxLengthBytes + ); + final Mono bindingDLQ = creator.bind( + BindingSpecification.binding(eventsDLQExchangeName, "#", queueName + ".DLQ") + ); + final Mono retryBinding = creator.bind( + BindingSpecification.binding(retryExchangeName, "#", queueName) + ); + return declareExchange.then(retryExchange) + .then(declareExchangeDLQ) + .then(declareQueue) + .then(declareDLQ) + .thenMany(bindings) + .then(bindingDLQ) + .then(retryBinding) + .then(); } else { final Mono declareQueue = creator.declareQueue(queueName, maxLengthBytes); return declareExchange.then(declareQueue).thenMany(bindings).then(); diff --git a/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationNotificationListener.java b/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationNotificationListener.java index 6a6e4336..2f0a7e03 100644 --- a/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationNotificationListener.java +++ b/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationNotificationListener.java @@ -53,28 +53,21 @@ public ApplicationNotificationListener(ReactiveMessageListener receiver, protected Mono setUpBindings(TopologyCreator creator) { final Mono declareQueue = creator.declare( - queue(queueName) - .durable(false) - .autoDelete(true) - .exclusive(true)); + queue(queueName).durable(false).autoDelete(true).exclusive(true) + ); final Flux bindings = fromIterable(resolver.getNotificationListeners()) - .flatMap(listener -> creator.bind(binding(exchangeName, listener.getPath(), queueName))); + .flatMap(listener -> creator.bind( + binding(exchangeName, listener.getPath(), queueName)) + ); if (createTopology) { - final Mono declareExchange = creator.declare(exchange(exchangeName) - .type("topic") - .durable(true)); - - return declareExchange + return creator.declare(exchange(exchangeName).type("topic").durable(true)) .then(declareQueue) .thenMany(bindings) .then(); - } else { - return declareQueue - .thenMany(bindings) - .then(); } + return declareQueue.thenMany(bindings).then(); } @Override @@ -84,15 +77,12 @@ protected Function> rawMessageHandler(String executorPath) Function converter = resolveConverter(eventListener); final EventExecutor executor = new EventExecutor<>(eventListener.getHandler(), converter); - return message -> executor - .execute(message) - .cast(Object.class); + return message -> executor.execute(message).cast(Object.class); } @Override protected String getExecutorPath(AcknowledgableDelivery message) { - return message.getEnvelope() - .getRoutingKey(); + return message.getEnvelope().getRoutingKey(); } @Override diff --git a/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationQueryListener.java b/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationQueryListener.java index 90c80154..142ee1a9 100644 --- a/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationQueryListener.java +++ b/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/ApplicationQueryListener.java @@ -66,7 +66,8 @@ public ApplicationQueryListener(ReactiveMessageListener listener, String queueNa protected Function> rawMessageHandler(String executorPath) { final RegisteredQueryHandler handler = handlerResolver.getQueryHandler(executorPath); if (handler == null) { - return message -> Mono.error(new RuntimeException("Handler Not registered for Query: " + executorPath)); + return message -> + Mono.error(new RuntimeException("Handler Not registered for Query: " + executorPath)); } Function messageConverter = resolveConverter(handler.getQueryClass()); final QueryExecutor executor = new QueryExecutor<>(handler.getHandler(), messageConverter); @@ -81,17 +82,36 @@ private Function resolveConverter(Class handlerClass) { } protected Mono setUpBindings(TopologyCreator creator) { - final Mono declareExchange = creator.declare(ExchangeSpecification.exchange(directExchange).durable(true).type("direct")); + final Mono declareExchange = creator.declare( + ExchangeSpecification.exchange(directExchange).durable(true).type("direct") + ); if (withDLQRetry) { - final Mono declareExchangeDLQ = creator.declare(ExchangeSpecification.exchange(directExchange + ".DLQ").durable(true).type("direct")); - final Mono declareQueue = creator.declareQueue(queueName, directExchange + ".DLQ", maxLengthBytes); - final Mono declareDLQ = creator.declareDLQ(queueName, directExchange, retryDelay, maxLengthBytes); - final Mono binding = creator.bind(BindingSpecification.binding(directExchange, queueName, queueName)); - final Mono bindingDLQ = creator.bind(BindingSpecification.binding(directExchange + ".DLQ", queueName, queueName + ".DLQ")); - return declareExchange.then(declareExchangeDLQ).then(declareQueue).then(declareDLQ).then(binding).then(bindingDLQ).then(); + final Mono declareExchangeDLQ = creator.declare( + ExchangeSpecification.exchange(directExchange + ".DLQ").durable(true).type("direct") + ); + final Mono declareQueue = creator.declareQueue( + queueName, directExchange + ".DLQ", maxLengthBytes + ); + final Mono declareDLQ = creator.declareDLQ( + queueName, directExchange, retryDelay, maxLengthBytes + ); + final Mono binding = creator.bind( + BindingSpecification.binding(directExchange, queueName, queueName) + ); + final Mono bindingDLQ = creator.bind( + BindingSpecification.binding(directExchange + ".DLQ", queueName, queueName + ".DLQ") + ); + return declareExchange + .then(declareExchangeDLQ) + .then(declareQueue) + .then(declareDLQ) + .then(binding) + .then(bindingDLQ) + .then(); } else { final Mono declareQueue = creator.declareQueue(queueName, maxLengthBytes); - final Mono binding = creator.bind(BindingSpecification.binding(directExchange, queueName, queueName)); + final Mono binding = creator.bind( + BindingSpecification.binding(directExchange, queueName, queueName)); return declareExchange.then(declareQueue).then(binding).then(); } } diff --git a/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/GenericMessageListener.java b/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/GenericMessageListener.java index 27811aa5..82e32ac1 100644 --- a/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/GenericMessageListener.java +++ b/async/async-rabbit/src/main/java/org/reactivecommons/async/rabbit/listeners/GenericMessageListener.java @@ -33,6 +33,7 @@ import static reactor.core.publisher.Mono.defer; @Log +@SuppressWarnings({"unchecked", "rawtypes"}) public abstract class GenericMessageListener { public static final int DEFAULT_RETRIES_DLQ = 10; private final ConcurrentHashMap>> handlers = new ConcurrentHashMap<>(); @@ -51,9 +52,10 @@ public abstract class GenericMessageListener { private final CustomReporter customReporter; private volatile Flux messageFlux; - public GenericMessageListener(String queueName, ReactiveMessageListener listener, boolean useDLQRetries, - boolean createTopology, long maxRetries, long retryDelay, DiscardNotifier discardNotifier, - String objectType, CustomReporter customReporter) { + protected GenericMessageListener(String queueName, ReactiveMessageListener listener, boolean useDLQRetries, + boolean createTopology, long maxRetries, long retryDelay, + DiscardNotifier discardNotifier, String objectType, + CustomReporter customReporter) { this.receiver = listener.getReceiver(); this.queueName = queueName; this.messageListener = listener; @@ -79,9 +81,13 @@ protected Mono setUpBindings(TopologyCreator creator) { } public void startListener() { - log.log(Level.INFO, "Using max concurrency {0}, in queue: {1}", new Object[]{messageListener.getMaxConcurrency(), queueName}); + log.log(Level.INFO, "Using max concurrency {0}, in queue: {1}", + new Object[]{messageListener.getMaxConcurrency(), queueName} + ); if (useDLQRetries) { - log.log(Level.INFO, "ATTENTION! Using DLQ Strategy for retries with {0} + 1 Max Retries configured!", new Object[]{maxRetries}); + log.log(Level.INFO, "ATTENTION! Using DLQ Strategy for retries with {0} + 1 Max Retries configured!", + new Object[]{maxRetries} + ); } else { log.log(Level.INFO, "ATTENTION! Using infinite fast retries as Retry Strategy"); } @@ -99,7 +105,6 @@ public void startListener() { .transform(this::consumeFaultTolerant); } - onTerminate(); } @@ -175,7 +180,9 @@ private void doLogExecution(String executorPath, long timeElapsed) { protected void logError(Throwable err, AcknowledgableDelivery msj, FallbackStrategy strategy) { String messageID = msj.getProperties().getMessageId(); try { - log.log(Level.SEVERE, format("Error encounter while processing message %s: %s", messageID, err.toString()), err); + log.log(Level.SEVERE, + format("Error encounter while processing message %s: %s", messageID, err.toString()), err + ); log.warning(format("Message %s Headers: %s", messageID, msj.getProperties().getHeaders().toString())); log.warning(format("Message %s Body: %s", messageID, new String(msj.getBody()))); } catch (Exception e) { diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/helpers/TestStubs.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/helpers/TestStubs.java index 6736ed1a..280a84e9 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/helpers/TestStubs.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/helpers/TestStubs.java @@ -14,7 +14,7 @@ public static Message mockMessage() { properties.getHeaders().put(REPLY_ID, "reply"); properties.getHeaders().put(CORRELATION_ID, "correlation"); properties.getHeaders().put(SERVED_QUERY_ID, "my-query"); - return new RabbitMessage("{\"id\":\"id\",\"name\":\"name\",\"date\":\"2020-10-22T17:03:26.062Z\"}".getBytes() - , properties); + return new RabbitMessage("{\"id\":\"id\",\"name\":\"name\",\"date\":\"2020-10-22T17:03:26.062Z\"}".getBytes(), + properties); } } diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/HandlerResolverTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/HandlerResolverTest.java index a5b2dd6e..1f6137ae 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/HandlerResolverTest.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/HandlerResolverTest.java @@ -20,15 +20,27 @@ class HandlerResolverTest { void setup() { Map> commandHandlers = new ConcurrentHashMap<>(); Map> eventListeners = new ConcurrentHashMap<>(); - eventListeners.put("event.name", new RegisteredEventListener<>("event.name", message -> Mono.empty(), String.class)); - eventListeners.put("event.name2", new RegisteredEventListener<>("event.name2", message -> Mono.empty(), String.class)); - eventListeners.put("some.*", new RegisteredEventListener<>("some.*", message -> Mono.empty(), String.class)); + eventListeners.put("event.name", new RegisteredEventListener<>( + "event.name", message -> Mono.empty(), String.class) + ); + eventListeners.put("event.name2", new RegisteredEventListener<>( + "event.name2", message -> Mono.empty(), String.class) + ); + eventListeners.put("some.*", new RegisteredEventListener<>( + "some.*", message -> Mono.empty(), String.class) + ); Map> eventsToBind = new ConcurrentHashMap<>(); - eventsToBind.put("event.name", new RegisteredEventListener<>("event.name", message -> Mono.empty(), String.class)); - eventsToBind.put("event.name2", new RegisteredEventListener<>("event.name2", message -> Mono.empty(), String.class)); + eventsToBind.put("event.name", new RegisteredEventListener<>( + "event.name", message -> Mono.empty(), String.class) + ); + eventsToBind.put("event.name2", new RegisteredEventListener<>( + "event.name2", message -> Mono.empty(), String.class) + ); Map> notificationEventListeners = new ConcurrentHashMap<>(); Map> queryHandlers = new ConcurrentHashMap<>(); - resolver = new HandlerResolver(queryHandlers, eventListeners, eventsToBind, notificationEventListeners, commandHandlers); + resolver = new HandlerResolver( + queryHandlers, eventListeners, eventsToBind, notificationEventListeners, commandHandlers + ); } @Test diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/RabbitDirectAsyncGatewayTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/RabbitDirectAsyncGatewayTest.java index d55addd5..05c408a5 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/RabbitDirectAsyncGatewayTest.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/RabbitDirectAsyncGatewayTest.java @@ -68,14 +68,14 @@ class RabbitDirectAsyncGatewayTest { private final MeterRegistry meterRegistry = new SimpleMeterRegistry(); private RabbitDirectAsyncGateway asyncGateway; - public void init(ReactiveMessageSender sender) { + void init(ReactiveMessageSender sender) { asyncGateway = new RabbitDirectAsyncGateway(config, router, sender, "exchange", converter, meterRegistry); } @Test void shouldReleaseRouterResourcesOnTimeout() { - BrokerConfig config = new BrokerConfig(false, false, false, Duration.ofSeconds(1)); - asyncGateway = new RabbitDirectAsyncGateway(config, router, senderMock, "ex", converter, meterRegistry); + BrokerConfig brokerConfig = new BrokerConfig(false, false, false, Duration.ofSeconds(1)); + asyncGateway = new RabbitDirectAsyncGateway(brokerConfig, router, senderMock, "ex", converter, meterRegistry); when(router.register(anyString())).thenReturn(Mono.never()); when(senderMock.sendNoConfirm(any(), anyString(), anyString(), anyMap(), anyBoolean())) .thenReturn(Mono.empty()); @@ -98,8 +98,10 @@ void shouldSendInOptimalTime() throws InterruptedException { int messageCount = 40000; final Flux> messages = createMessagesHot(messageCount); final Flux target = - messages.flatMap(dummyMessageCommand -> asyncGateway.sendCommand(dummyMessageCommand, "testTarget") - .doOnSuccess(aVoid -> semaphore.release())); + messages.flatMap(dummyMessageCommand -> + asyncGateway.sendCommand(dummyMessageCommand, "testTarget") + .doOnSuccess(aVoid -> semaphore.release()) + ); final long init = System.currentTimeMillis(); target.subscribe(); @@ -118,7 +120,7 @@ void shouldSendInOptimalTime() throws InterruptedException { @Test @SuppressWarnings("unchecked") - public void shouldReplyQuery() { + void shouldReplyQuery() { // Arrange senderMock(); @@ -132,13 +134,15 @@ public void shouldReplyQuery() { StepVerifier.create(result).verifyComplete(); ArgumentCaptor> headersCaptor = ArgumentCaptor.forClass(Map.class); verify(senderMock, times(1)) - .sendNoConfirm(eq(response), eq("globalReply"), eq("replyId"), headersCaptor.capture(), anyBoolean()); + .sendNoConfirm(eq(response), eq("globalReply"), eq("replyId"), + headersCaptor.capture(), anyBoolean() + ); assertThat(headersCaptor.getValue().get(CORRELATION_ID)).isEqualTo("correlationId"); } @Test @SuppressWarnings("unchecked") - public void shouldReplyQueryWithout() { + void shouldReplyQueryWithout() { // Arrange senderMock(); @@ -158,7 +162,7 @@ public void shouldReplyQueryWithout() { @Test @SuppressWarnings("unchecked") - public void shouldHandleRequestReply() throws JsonProcessingException { + void shouldHandleRequestReply() throws JsonProcessingException { // Arrange senderMock(); mockReply(); diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/RabbitMessageTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/RabbitMessageTest.java index 536cb968..f93864ab 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/RabbitMessageTest.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/RabbitMessageTest.java @@ -16,7 +16,9 @@ class RabbitMessageTest { void shouldCreateFromDelivery() { Envelope env = new Envelope(2, false, "exchange", "routeKey"); Map headers = new HashMap<>(); - AMQP.BasicProperties props = new AMQP.BasicProperties.Builder().contentType("content").contentEncoding("utf8").headers(headers).build(); + AMQP.BasicProperties props = new AMQP.BasicProperties.Builder() + .contentType("content").contentEncoding("utf8").headers(headers) + .build(); byte[] body = new byte[]{3, 4, 5, 6}; Delivery delivery = new Delivery(env, props, body); diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/communications/ReactiveMessageSenderTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/communications/ReactiveMessageSenderTest.java index 1dd463d8..95e74a4e 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/communications/ReactiveMessageSenderTest.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/communications/ReactiveMessageSenderTest.java @@ -25,10 +25,9 @@ import static org.mockito.Mockito.when; @ExtendWith(MockitoExtension.class) +@SuppressWarnings("unchecked") class ReactiveMessageSenderTest { - private final String sourceApplication = "TestApp"; - private ReactiveMessageSender messageSender; private final ObjectMapper objectMapper = new ObjectMapper(); @@ -43,12 +42,11 @@ class ReactiveMessageSenderTest { public void init() { when(sender.sendWithTypedPublishConfirms(any(Publisher.class))).then(invocation -> { final Flux argument = invocation.getArgument(0); - return argument.map(myOutboundMessage -> { - OutboundMessageResult outboundMessageResult = new OutboundMessageResult<>(myOutboundMessage, true); - return outboundMessageResult; - }); + return argument + .map(myOutboundMessage -> new OutboundMessageResult<>(myOutboundMessage, true)); }); when(sender.send(any(Publisher.class))).thenReturn(Mono.empty()); + String sourceApplication = "TestApp"; messageSender = new ReactiveMessageSender(sender, sourceApplication, messageConverter, null); } diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/converters/json/CloudEventBuilderExtTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/converters/json/CloudEventBuilderExtTest.java index a12f0d37..2136f319 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/converters/json/CloudEventBuilderExtTest.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/converters/json/CloudEventBuilderExtTest.java @@ -1,6 +1,5 @@ package org.reactivecommons.async.rabbit.converters.json; -import com.fasterxml.jackson.databind.ObjectMapper; import org.junit.jupiter.api.Test; import org.reactivecommons.async.commons.converters.json.CloudEventBuilderExt; @@ -8,12 +7,10 @@ import static org.assertj.core.api.Assertions.assertThat; -public class CloudEventBuilderExtTest { - - private final ObjectMapper objectMapper = new ObjectMapper(); +class CloudEventBuilderExtTest { @Test - void asBytes(){ + void asBytes() { Date date = new Date(); SampleClass result = new SampleClass("35", "name1", date); byte[] arrayByte = CloudEventBuilderExt.asBytes(result); diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/converters/json/JacksonMessageConverterTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/converters/json/JacksonMessageConverterTest.java index 0376ae96..15b697b4 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/converters/json/JacksonMessageConverterTest.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/converters/json/JacksonMessageConverterTest.java @@ -69,7 +69,9 @@ void readCloudEvent() { .withId(UUID.randomUUID().toString()) // .withSource(URI.create("https://spring.io/foos"))// .withType("command") - .withData("application/json", JsonCloudEventData.wrap(objectMapper.valueToTree(new SampleClass("35", "name1", date)))) + .withData("application/json", JsonCloudEventData.wrap( + objectMapper.valueToTree(new SampleClass("35", "name1", date))) + ) .build(); Message message = converter.toMessage(command); CloudEvent result = converter.readCloudEvent(message); diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationCommandListenerPerfTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationCommandListenerPerfTest.java index c8df1070..0b12f4fc 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationCommandListenerPerfTest.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationCommandListenerPerfTest.java @@ -51,7 +51,7 @@ class ApplicationCommandListenerPerfTest { private static final CountDownLatch latch = new CountDownLatch(12 + 1); - private static final int messageCount = 40000; + private static final int MESSAGE_COUNT = 40000; private final Semaphore semaphore = new Semaphore(0); @Mock private Receiver receiver; @@ -62,7 +62,9 @@ class ApplicationCommandListenerPerfTest { @Mock private CustomReporter errorReporter; private StubGenericMessageListener messageListener; - private MessageConverter messageConverter = new RabbitJacksonMessageConverter(new DefaultObjectMapperSupplier().get()); + private final MessageConverter messageConverter = new RabbitJacksonMessageConverter( + new DefaultObjectMapperSupplier().get() + ); private ReactiveMessageListener reactiveMessageListener; private static BigInteger makeHardWork() { @@ -98,19 +100,21 @@ void shouldProcessMessagesInOptimalTime() throws JsonProcessingException, Interr HandlerResolver handlerResolver = createHandlerResolver(HandlerRegistry.register() .handleCommand("app.command.test", this::handleTestMessage, DummyMessage.class) ); - messageListener = new StubGenericMessageListener("test-queue", reactiveMessageListener, true, 10, discardNotifier, "command", handlerResolver, messageConverter, errorReporter); - Flux messageFlux = createSource(messageCount); + messageListener = new StubGenericMessageListener("test-queue", reactiveMessageListener, true, 10, + discardNotifier, "command", handlerResolver, messageConverter, errorReporter + ); + Flux messageFlux = createSource(MESSAGE_COUNT); TestUtils.instructSafeReceiverMock(receiver, messageFlux); messageListener.startListener(); final long init = System.currentTimeMillis(); latch.countDown(); - semaphore.acquire(messageCount); + semaphore.acquire(MESSAGE_COUNT); final long end = System.currentTimeMillis(); final long total = end - init; - final double microsPerMessage = ((total + 0.0) / messageCount) * 1000; - System.out.println("Message count: " + messageCount); + final double microsPerMessage = ((total + 0.0) / MESSAGE_COUNT) * 1000; + System.out.println("Message count: " + MESSAGE_COUNT); System.out.println("Total Execution Time: " + total + "ms"); System.out.println("Microseconds per message: " + microsPerMessage + "us"); if (System.getProperty("env.ci") == null) { @@ -127,18 +131,20 @@ void shouldProcessAsyncMessagesConcurrent() throws JsonProcessingException, Inte HandlerResolver handlerResolver = createHandlerResolver(HandlerRegistry.register() .handleCommand("app.command.test", this::handleTestMessageDelay, DummyMessage.class) ); - messageListener = new StubGenericMessageListener("test-queue", reactiveMessageListener, true, 10, discardNotifier, "command", handlerResolver, messageConverter, errorReporter); - Flux messageFlux = createSource(messageCount); + messageListener = new StubGenericMessageListener("test-queue", reactiveMessageListener, true, 10, + discardNotifier, "command", handlerResolver, messageConverter, errorReporter + ); + Flux messageFlux = createSource(MESSAGE_COUNT); TestUtils.instructSafeReceiverMock(receiver, messageFlux); System.out.println("Permits before: " + semaphore.availablePermits()); final long init = System.currentTimeMillis(); messageListener.startListener(); - semaphore.acquire(messageCount); + semaphore.acquire(MESSAGE_COUNT); final long end = System.currentTimeMillis(); final long total = end - init; - final double microsPerMessage = ((total + 0.0) / messageCount) * 1000; - System.out.println("Message count: " + messageCount); + final double microsPerMessage = ((total + 0.0) / MESSAGE_COUNT) * 1000; + System.out.println("Message count: " + MESSAGE_COUNT); System.out.println("Total Execution Time: " + total + "ms"); System.out.println("Microseconds per message: " + microsPerMessage + "us"); if (System.getProperty("env.ci") == null) { @@ -183,7 +189,9 @@ void shouldProcessCPUMessagesInParallel() throws JsonProcessingException, Interr ); int messageCount = 2000; reactiveMessageListener = new ReactiveMessageListener(receiver, topologyCreator, 250, 250); - messageListener = new StubGenericMessageListener("test-queue", reactiveMessageListener, true, 10, discardNotifier, "command", handlerResolver, messageConverter, errorReporter); + messageListener = new StubGenericMessageListener("test-queue", reactiveMessageListener, true, 10, + discardNotifier, "command", handlerResolver, messageConverter, errorReporter + ); Flux messageFlux = createSource(messageCount); TestUtils.instructSafeReceiverMock(receiver, messageFlux); @@ -211,7 +219,8 @@ void shouldProcessCPUWorkMessagesInParallel() throws JsonProcessingException, In ); int messageCount = 2000; reactiveMessageListener = new ReactiveMessageListener(receiver, topologyCreator, 500, 250); - messageListener = new StubGenericMessageListener("test-queue", reactiveMessageListener, true, 10, discardNotifier, "command", handlerResolver, messageConverter, errorReporter); + messageListener = new StubGenericMessageListener("test-queue", reactiveMessageListener, true, 10, + discardNotifier, "command", handlerResolver, messageConverter, errorReporter); Flux messageFlux = createSource(messageCount); TestUtils.instructSafeReceiverMock(receiver, messageFlux); @@ -239,7 +248,8 @@ void shouldProcessPasiveBlockingMessagesInParallel() throws JsonProcessingExcept ); int messageCount = 2000; reactiveMessageListener = new ReactiveMessageListener(receiver, topologyCreator, 500, 250); - messageListener = new StubGenericMessageListener("test-queue", reactiveMessageListener, true, 10, discardNotifier, "command", handlerResolver, messageConverter, errorReporter); + messageListener = new StubGenericMessageListener("test-queue", reactiveMessageListener, true, 10, + discardNotifier, "command", handlerResolver, messageConverter, errorReporter); Flux messageFlux = createSource(messageCount); TestUtils.instructSafeReceiverMock(receiver, messageFlux); @@ -261,20 +271,25 @@ void shouldProcessPasiveBlockingMessagesInParallel() throws JsonProcessingExcept } private HandlerResolver createHandlerResolver(final HandlerRegistry initialRegistry) { - final HandlerRegistry registry = range(0, 20).reduce(initialRegistry, (r, i) -> r.handleCommand("app.command.name" + i, message -> Mono.empty(), Map.class)).block(); - final ConcurrentMap> commandHandlers = registry.getCommandHandlers().stream() - .collect(ConcurrentHashMap::new, (map, handler) -> map.put(handler.getPath(), handler), ConcurrentHashMap::putAll); + final HandlerRegistry registry = range(0, 20) + .reduce(initialRegistry, (r, i) -> + r.handleCommand("app.command.name" + i, message -> Mono.empty(), Map.class) + ) + .block(); + final ConcurrentMap> commandHandlers = registry.getCommandHandlers() + .stream() + .collect(ConcurrentHashMap::new, (map, handler) -> + map.put(handler.getPath(), handler), ConcurrentHashMap::putAll + ); return new HandlerResolver(null, null, null, null, commandHandlers) { @Override @SuppressWarnings("unchecked") public RegisteredCommandHandler getCommandHandler(String path) { - final RegisteredCommandHandler handler = (RegisteredCommandHandler) super.getCommandHandler(path); - return handler != null ? handler : new RegisteredCommandHandler>("", new DefaultCommandHandler() { - @Override - public Mono handle(Command message) { - return Mono.error(new RuntimeException("Default handler in Test")); - } - }, Object.class); + final RegisteredCommandHandler handler = super.getCommandHandler(path); + return handler != null ? handler : new RegisteredCommandHandler<>( + "", (DefaultCommandHandler) message -> + Mono.error(new RuntimeException("Default handler in Test")), Object.class + ); } }; } @@ -282,7 +297,9 @@ public Mono handle(Command message) { private Flux createSource(int count) throws JsonProcessingException { ObjectMapper mapper = new ObjectMapper(); - Command command = new Command<>("app.command.test", UUID.randomUUID().toString(), new DummyMessage()); + Command command = new Command<>( + "app.command.test", UUID.randomUUID().toString(), new DummyMessage() + ); String data = mapper.writeValueAsString(command); final List list = IntStream.range(0, count).mapToObj(value -> { AMQP.BasicProperties props = new AMQP.BasicProperties(); @@ -312,10 +329,14 @@ private AMQP.BasicProperties createProps() { null); } - class StubGenericMessageListener extends ApplicationCommandListener { + static class StubGenericMessageListener extends ApplicationCommandListener { - public StubGenericMessageListener(String queueName, ReactiveMessageListener listener, boolean useDLQRetries, long maxRetries, DiscardNotifier discardNotifier, String objectType, HandlerResolver handlerResolver, MessageConverter messageConverter, CustomReporter errorReporter) { - super(listener, queueName, handlerResolver, "directExchange", messageConverter, true, false, false, 10, 10, Optional.empty(), discardNotifier, errorReporter); + public StubGenericMessageListener(String queueName, ReactiveMessageListener listener, boolean useDLQRetries, + long maxRetries, DiscardNotifier discardNotifier, String objectType, + HandlerResolver handlerResolver, MessageConverter messageConverter, + CustomReporter errorReporter) { + super(listener, queueName, handlerResolver, "directExchange", messageConverter, true, false, false, 10, 10, + Optional.empty(), discardNotifier, errorReporter); } } diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationCommandListenerTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationCommandListenerTest.java index e5f63737..fa72d55a 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationCommandListenerTest.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationCommandListenerTest.java @@ -17,31 +17,45 @@ import static reactor.core.publisher.Mono.error; @ExtendWith(MockitoExtension.class) -public class ApplicationCommandListenerTest extends ListenerReporterTestSuperClass{ +@SuppressWarnings("unchecked") +public class ApplicationCommandListenerTest extends ListenerReporterTestSuperClass { - private final Command command = new Command<>("app.command.test", UUID.randomUUID().toString(), new DummyMessage()); - private final Command command2 = new Command<>("app.command.test2", UUID.randomUUID().toString(), new DummyMessage()); + private final Command command = new Command<>( + "app.command.test", UUID.randomUUID().toString(), new DummyMessage() + ); + private final Command command2 = new Command<>( + "app.command.test2", UUID.randomUUID().toString(), new DummyMessage() + ); @Test void shouldSendErrorToCustomErrorReporter() throws InterruptedException { final HandlerRegistry registry = HandlerRegistry.register() - .handleCommand("app.command.test", m -> error(new RuntimeException("testEx")), DummyMessage.class); + .handleCommand("app.command.test", m -> + error(new RuntimeException("testEx")), DummyMessage.class + ); assertSendErrorToCustomReporter(registry, createSource(Command::getName, command)); } @Test void shouldSendErrorMetricToCustomErrorReporter() throws InterruptedException { final HandlerRegistry registry = HandlerRegistry.register() - .handleCommand("app.command.test", m -> error(new RuntimeException("testEx")), DummyMessage.class); + .handleCommand("app.command.test", + m -> error(new RuntimeException("testEx")), DummyMessage.class + ); assertSendErrorToCustomReporter(registry, createSource(Command::getName, command)); - verify(errorReporter).reportMetric(eq("command"), eq("app.command.test"), longThat(time -> time >= 0 ), eq(false)); + verify(errorReporter) + .reportMetric(eq("command"), eq("app.command.test"), longThat(time -> time >= 0), eq(false)); } @Test void shouldContinueAfterReportError() throws InterruptedException { final HandlerRegistry handlerRegistry = HandlerRegistry.register() - .handleCommand("app.command.test", m -> error(new RuntimeException("testEx")), DummyMessage.class) - .handleCommand("app.command.test2", m -> Mono.fromRunnable(successSemaphore::release), DummyMessage.class); + .handleCommand("app.command.test", + m -> error(new RuntimeException("testEx")), DummyMessage.class + ) + .handleCommand("app.command.test2", + m -> Mono.fromRunnable(successSemaphore::release), DummyMessage.class + ); assertContinueAfterSendErrorToCustomReporter(handlerRegistry, createSource(Command::getName, command, command2)); } @@ -54,7 +68,8 @@ protected GenericMessageListener createMessageListener(HandlerResolver handlerRe class StubGenericMessageListener extends ApplicationCommandListener { public StubGenericMessageListener(HandlerResolver handlerResolver) { - super(reactiveMessageListener, "queueName", handlerResolver, "directExchange", messageConverter, true, false,false,10, 10, Optional.empty(), discardNotifier, errorReporter); + super(reactiveMessageListener, "queueName", handlerResolver, "directExchange", messageConverter, true, + false, false, 10, 10, Optional.empty(), discardNotifier, errorReporter); } } } diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationEventListenerTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationEventListenerTest.java index 62daa8a1..763785f7 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationEventListenerTest.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationEventListenerTest.java @@ -14,23 +14,35 @@ import static reactor.core.publisher.Mono.error; @ExtendWith(MockitoExtension.class) +@SuppressWarnings("unchecked") public class ApplicationEventListenerTest extends ListenerReporterTestSuperClass { - private DomainEvent event1 = new DomainEvent<>("app.event.test", UUID.randomUUID().toString(), new DummyMessage()); - private DomainEvent event2 = new DomainEvent<>("app.event.test2", UUID.randomUUID().toString(), new DummyMessage()); + private final DomainEvent event1 = new DomainEvent<>( + "app.event.test", UUID.randomUUID().toString(), new DummyMessage() + ); + + private final DomainEvent event2 = new DomainEvent<>( + "app.event.test2", UUID.randomUUID().toString(), new DummyMessage() + ); @Test void shouldSendErrorToCustomErrorReporter() throws InterruptedException { final HandlerRegistry registry = HandlerRegistry.register() - .listenEvent("app.event.test", m -> error(new RuntimeException("testEx")), DummyMessage.class); + .listenEvent("app.event.test", + m -> error(new RuntimeException("testEx")), DummyMessage.class + ); assertSendErrorToCustomReporter(registry, createSource(DomainEvent::getName, event1)); } @Test void shouldContinueAfterReportError() throws InterruptedException { final HandlerRegistry handlerRegistry = HandlerRegistry.register() - .listenEvent("app.event.test", m -> error(new RuntimeException("testEx")), DummyMessage.class) - .listenEvent("app.event.test2", m -> Mono.fromRunnable(successSemaphore::release), DummyMessage.class); + .listenEvent("app.event.test", + m -> error(new RuntimeException("testEx")), DummyMessage.class + ) + .listenEvent("app.event.test2", + m -> Mono.fromRunnable(successSemaphore::release), DummyMessage.class + ); assertContinueAfterSendErrorToCustomReporter(handlerRegistry, createSource(DomainEvent::getName, event1, event2)); } @@ -42,7 +54,8 @@ protected GenericMessageListener createMessageListener(HandlerResolver handlerRe class StubGenericMessageListener extends ApplicationEventListener { public StubGenericMessageListener(HandlerResolver handlerResolver) { - super(reactiveMessageListener, "queueName", "domainEvents", handlerResolver, messageConverter, true, true,10, 10, Optional.empty(), discardNotifier, errorReporter, ""); + super(reactiveMessageListener, "queueName", "domainEvents", handlerResolver, messageConverter, true, true, + 10, 10, Optional.empty(), discardNotifier, errorReporter, ""); } } } diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationNotificationListenerTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationNotificationListenerTest.java index 8b146860..afcc5fff 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationNotificationListenerTest.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationNotificationListenerTest.java @@ -22,8 +22,12 @@ @ExtendWith(MockitoExtension.class) public class ApplicationNotificationListenerTest extends ListenerReporterTestSuperClass { - private DomainEvent event1 = new DomainEvent<>("app.event.test", UUID.randomUUID().toString(), new DummyMessage()); - private DomainEvent event2 = new DomainEvent<>("app.event.test2", UUID.randomUUID().toString(), new DummyMessage()); + private final DomainEvent event1 = new DomainEvent<>( + "app.event.test", UUID.randomUUID().toString(), new DummyMessage() + ); + private final DomainEvent event2 = new DomainEvent<>( + "app.event.test2", UUID.randomUUID().toString(), new DummyMessage() + ); @BeforeEach public void initCreator() { @@ -33,15 +37,20 @@ public void initCreator() { @Test void shouldSendErrorToCustomErrorReporter() throws InterruptedException { final HandlerRegistry registry = HandlerRegistry.register() - .listenNotificationEvent("app.event.test", m -> error(new RuntimeException("testEx")), DummyMessage.class); + .listenNotificationEvent("app.event.test", + m -> error(new RuntimeException("testEx")), DummyMessage.class); assertSendErrorToCustomReporter(registry, createSource(DomainEvent::getName, event1)); } @Test void shouldContinueAfterReportError() throws InterruptedException { final HandlerRegistry handlerRegistry = HandlerRegistry.register() - .listenNotificationEvent("app.event.test", m -> error(new RuntimeException("testEx")), DummyMessage.class) - .listenNotificationEvent("app.event.test2", m -> Mono.fromRunnable(successSemaphore::release), DummyMessage.class); + .listenNotificationEvent("app.event.test", + m -> error(new RuntimeException("testEx")), DummyMessage.class + ) + .listenNotificationEvent("app.event.test2", + m -> Mono.fromRunnable(successSemaphore::release), DummyMessage.class + ); assertContinueAfterSendErrorToCustomReporter(handlerRegistry, createSource(DomainEvent::getName, event1, event2)); } @@ -54,7 +63,8 @@ protected GenericMessageListener createMessageListener(HandlerResolver handlerRe class StubGenericMessageListener extends ApplicationNotificationListener { public StubGenericMessageListener(HandlerResolver handlerResolver) { - super(reactiveMessageListener, "exchange", "queue", true, handlerResolver, messageConverter, discardNotifier, errorReporter); + super(reactiveMessageListener, "exchange", "queue", true, handlerResolver, + messageConverter, discardNotifier, errorReporter); } } diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationQueryListenerErrorTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationQueryListenerErrorTest.java index b5ec8c32..a2ed493c 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationQueryListenerErrorTest.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ApplicationQueryListenerErrorTest.java @@ -17,21 +17,27 @@ @ExtendWith(MockitoExtension.class) public class ApplicationQueryListenerErrorTest extends ListenerReporterTestSuperClass { - private AsyncQuery event1 = new AsyncQuery<>("app.query.test", new DummyMessage()); - private AsyncQuery event2 = new AsyncQuery<>("app.query.test2", new DummyMessage()); + private final AsyncQuery event1 = new AsyncQuery<>("app.query.test", new DummyMessage()); + private final AsyncQuery event2 = new AsyncQuery<>("app.query.test2", new DummyMessage()); @Test void shouldSendErrorToCustomErrorReporter() throws InterruptedException { final HandlerRegistry registry = HandlerRegistry.register() - .serveQuery("app.query.test", m -> error(new RuntimeException("testEx")), DummyMessage.class); + .serveQuery("app.query.test", + m -> error(new RuntimeException("testEx")), DummyMessage.class + ); assertSendErrorToCustomReporter(registry, createSource(AsyncQuery::getResource, event1)); } @Test void shouldContinueAfterReportError() throws InterruptedException { final HandlerRegistry handlerRegistry = HandlerRegistry.register() - .serveQuery("app.query.test", m -> error(new RuntimeException("testEx")), DummyMessage.class) - .serveQuery("app.query.test2", m -> Mono.fromRunnable(successSemaphore::release), DummyMessage.class); + .serveQuery("app.query.test", + m -> error(new RuntimeException("testEx")), DummyMessage.class + ) + .serveQuery("app.query.test2", + m -> Mono.fromRunnable(successSemaphore::release), DummyMessage.class + ); assertContinueAfterSendErrorToCustomReporter(handlerRegistry, createSource(AsyncQuery::getResource, event1, event2)); } diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/GenericMessageListenerPerfTest.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/GenericMessageListenerPerfTest.java index f7dd0377..1016683b 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/GenericMessageListenerPerfTest.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/GenericMessageListenerPerfTest.java @@ -2,24 +2,7 @@ import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; -import com.rabbitmq.client.AMQP; -import com.rabbitmq.client.BuiltinExchangeType; -import com.rabbitmq.client.CancelCallback; -import com.rabbitmq.client.Channel; -import com.rabbitmq.client.ConfirmCallback; -import com.rabbitmq.client.ConfirmListener; -import com.rabbitmq.client.Connection; -import com.rabbitmq.client.Consumer; -import com.rabbitmq.client.ConsumerShutdownSignalCallback; -import com.rabbitmq.client.DeliverCallback; -import com.rabbitmq.client.Delivery; -import com.rabbitmq.client.Envelope; -import com.rabbitmq.client.GetResponse; -import com.rabbitmq.client.Method; -import com.rabbitmq.client.ReturnCallback; -import com.rabbitmq.client.ReturnListener; -import com.rabbitmq.client.ShutdownListener; -import com.rabbitmq.client.ShutdownSignalException; +import com.rabbitmq.client.*; import lombok.Data; import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; @@ -78,10 +61,12 @@ class GenericMessageListenerPerfTest { private final Semaphore semaphore = new Semaphore(0); @BeforeEach - public void init() { + void init() { // when(errorReporter.reportError(any(Throwable.class), any(Message.class), any(Object.class))).thenReturn(Mono.empty()); ReactiveMessageListener reactiveMessageListener = new ReactiveMessageListener(receiver, topologyCreator); - messageListener = new StubGenericMessageListener("test-queue", reactiveMessageListener, true, true,10, discardNotifier, "command", errorReporter); + messageListener = new StubGenericMessageListener( + "test-queue", reactiveMessageListener, true, true, 10, discardNotifier, "command", errorReporter + ); } @@ -124,7 +109,9 @@ void referenceTime() throws JsonProcessingException, InterruptedException { private Flux createSource(int count) throws JsonProcessingException { ObjectMapper mapper = new ObjectMapper(); - Command command = new Command<>("some.command.name", UUID.randomUUID().toString(), new DummyMessage()); + Command command = new Command<>( + "some.command.name", UUID.randomUUID().toString(), new DummyMessage() + ); String data = mapper.writeValueAsString(command); final List list = IntStream.range(0, count).mapToObj(value -> { AMQP.BasicProperties props = new AMQP.BasicProperties(); @@ -156,8 +143,11 @@ private AMQP.BasicProperties createProps() { class StubGenericMessageListener extends GenericMessageListener { - public StubGenericMessageListener(String queueName, ReactiveMessageListener listener, boolean useDLQRetries, boolean createTopology, long maxRetries, DiscardNotifier discardNotifier, String objectType, CustomReporter errorReporter) { - super(queueName, listener, useDLQRetries, createTopology, maxRetries, 200, discardNotifier, objectType, errorReporter); + public StubGenericMessageListener(String queueName, ReactiveMessageListener listener, boolean useDLQRetries, + boolean createTopology, long maxRetries, DiscardNotifier discardNotifier, + String objectType, CustomReporter errorReporter) { + super(queueName, listener, useDLQRetries, createTopology, maxRetries, 200, discardNotifier, + objectType, errorReporter); } @Override @@ -580,7 +570,10 @@ public String basicConsume(String queue, boolean autoAck, String consumerTag, bo } @Override - public String basicConsume(String queue, boolean autoAck, String consumerTag, boolean noLocal, boolean exclusive, Map arguments, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback) throws IOException { + public String basicConsume(String queue, boolean autoAck, String consumerTag, boolean noLocal, boolean exclusive, + Map arguments, DeliverCallback deliverCallback, + CancelCallback cancelCallback, + ConsumerShutdownSignalCallback shutdownSignalCallback) throws IOException { return null; } diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ListenerReporterTestSuperClass.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ListenerReporterTestSuperClass.java index b70a2196..2cfeb669 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ListenerReporterTestSuperClass.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/rabbit/listeners/ListenerReporterTestSuperClass.java @@ -54,28 +54,41 @@ import static reactor.core.publisher.Mono.empty; import static reactor.core.publisher.Mono.just; +@SuppressWarnings("unchecked") public abstract class ListenerReporterTestSuperClass { protected final TopologyCreator topologyCreator = mock(TopologyCreator.class); protected final DiscardNotifier discardNotifier = mock(DiscardNotifier.class); - protected final MessageConverter messageConverter = new RabbitJacksonMessageConverter(new DefaultObjectMapperSupplier().get()); + protected final MessageConverter messageConverter = new RabbitJacksonMessageConverter( + new DefaultObjectMapperSupplier().get() + ); protected final CustomReporter errorReporter = mock(CustomReporter.class); protected final Semaphore semaphore = new Semaphore(0); protected final Semaphore successSemaphore = new Semaphore(0); private final ObjectMapper mapper = new ObjectMapper(); private final Receiver receiver = mock(Receiver.class); - protected final ReactiveMessageListener reactiveMessageListener = new ReactiveMessageListener(receiver, topologyCreator); + protected final ReactiveMessageListener reactiveMessageListener = new ReactiveMessageListener( + receiver, topologyCreator + ); private GenericMessageListener messageListener; @BeforeEach public void init() { - Mockito.when(topologyCreator.declare(any(ExchangeSpecification.class))).thenReturn(just(mock(AMQP.Exchange.DeclareOk.class))); - Mockito.when(topologyCreator.declareDLQ(any(String.class), any(String.class), any(Integer.class), any(Optional.class))).thenReturn(just(mock(AMQP.Queue.DeclareOk.class))); - Mockito.when(topologyCreator.declareQueue(any(String.class), any(String.class), any(Optional.class))).thenReturn(just(mock(AMQP.Queue.DeclareOk.class))); - Mockito.when(topologyCreator.bind(any(BindingSpecification.class))).thenReturn(just(mock(AMQP.Queue.BindOk.class))); + Mockito.when(topologyCreator.declare(any(ExchangeSpecification.class))) + .thenReturn(just(mock(AMQP.Exchange.DeclareOk.class))); + Mockito.when(topologyCreator.declareDLQ + (any(String.class), any(String.class), any(Integer.class), any(Optional.class)) + ) + .thenReturn(just(mock(AMQP.Queue.DeclareOk.class))); + Mockito.when(topologyCreator.declareQueue(any(String.class), any(String.class), any(Optional.class))) + .thenReturn(just(mock(AMQP.Queue.DeclareOk.class))); + Mockito.when(topologyCreator.bind(any(BindingSpecification.class))) + .thenReturn(just(mock(AMQP.Queue.BindOk.class))); } - protected void assertContinueAfterSendErrorToCustomReporter(HandlerRegistry handlerRegistry, Flux source) throws InterruptedException { + protected void assertContinueAfterSendErrorToCustomReporter(HandlerRegistry handlerRegistry, + Flux source) + throws InterruptedException { final HandlerResolver handlerResolver = createHandlerResolver(handlerRegistry); when(errorReporter.reportError(any(Throwable.class), any(Message.class), any(Object.class), any(Boolean.class))) .then(inv -> empty().doOnSuccess(o -> semaphore.release())); @@ -93,7 +106,8 @@ protected void assertContinueAfterSendErrorToCustomReporter(HandlerRegistry hand assertThat(processed).isTrue(); } - protected void assertSendErrorToCustomReporter(HandlerRegistry handlerRegistry, Flux source) throws InterruptedException { + protected void assertSendErrorToCustomReporter(HandlerRegistry handlerRegistry, Flux source) + throws InterruptedException { final HandlerResolver handlerResolver = createHandlerResolver(handlerRegistry); when(errorReporter.reportError(any(Throwable.class), any(Message.class), any(Object.class), any(Boolean.class))) .then(inv -> empty().doOnSuccess(o -> semaphore.release())); @@ -107,7 +121,8 @@ protected void assertSendErrorToCustomReporter(HandlerRegistry handlerRegistry, ArgumentCaptor throwableCaptor = ArgumentCaptor.forClass(Throwable.class); final boolean reported = semaphore.tryAcquire(1, TimeUnit.SECONDS); assertThat(reported).isTrue(); - verify(errorReporter).reportError(throwableCaptor.capture(), any(Message.class), any(Object.class), any(Boolean.class)); + verify(errorReporter + ).reportError(throwableCaptor.capture(), any(Message.class), any(Object.class), any(Boolean.class)); assertThat(throwableCaptor.getValue().getMessage()).isEqualTo("testEx"); } @@ -119,7 +134,9 @@ protected Flux createSource(Function rout .headers(Collections.singletonMap(Headers.SERVED_QUERY_ID, routeExtractor.apply(value))) .build(); - final Envelope envelope = new Envelope(new Random().nextInt(), true, "exchange", routeExtractor.apply(value)); + final Envelope envelope = new Envelope( + new Random().nextInt(), true, "exchange", routeExtractor.apply(value) + ); final Delivery delivery = new Delivery(envelope, props, data.getBytes()); return new AcknowledgableDelivery(delivery, new ChannelDummy(), null); }).collect(Collectors.toList()); @@ -130,11 +147,18 @@ protected Flux createSource(Function rout protected abstract GenericMessageListener createMessageListener(final HandlerResolver handlerResolver); private HandlerResolver createHandlerResolver(final HandlerRegistry registry) { - final Map> eventHandlers = Stream.concat(registry.getDynamicEventHandlers().stream(), registry.getDomainEventListeners().get(DEFAULT_DOMAIN).stream()).collect(toMap(RegisteredEventListener::getPath, identity())); - final Map> eventsToBind = registry.getDomainEventListeners().get(DEFAULT_DOMAIN).stream().collect(toMap(RegisteredEventListener::getPath, identity())); - final Map> notificationHandlers = registry.getEventNotificationListener().stream().collect(toMap(RegisteredEventListener::getPath, identity())); - final Map> queryHandlers = registry.getHandlers().stream().collect(toMap(RegisteredQueryHandler::getPath, identity())); - final Map> commandHandlers = registry.getCommandHandlers().stream().collect(toMap(RegisteredCommandHandler::getPath, identity())); + final Map> eventHandlers = Stream.concat( + registry.getDynamicEventHandlers().stream(), + registry.getDomainEventListeners().get(DEFAULT_DOMAIN).stream()) + .collect(toMap(RegisteredEventListener::getPath, identity())); + final Map> eventsToBind = registry.getDomainEventListeners() + .get(DEFAULT_DOMAIN).stream().collect(toMap(RegisteredEventListener::getPath, identity())); + final Map> notificationHandlers = registry.getEventNotificationListener() + .stream().collect(toMap(RegisteredEventListener::getPath, identity())); + final Map> queryHandlers = registry.getHandlers().stream() + .collect(toMap(RegisteredQueryHandler::getPath, identity())); + final Map> commandHandlers = registry.getCommandHandlers() + .stream().collect(toMap(RegisteredCommandHandler::getPath, identity())); return new HandlerResolver( new ConcurrentHashMap<>(queryHandlers), new ConcurrentHashMap<>(eventHandlers), diff --git a/async/async-rabbit/src/test/java/org/reactivecommons/async/utils/TestUtils.java b/async/async-rabbit/src/test/java/org/reactivecommons/async/utils/TestUtils.java index 10e3079f..c42709fe 100644 --- a/async/async-rabbit/src/test/java/org/reactivecommons/async/utils/TestUtils.java +++ b/async/async-rabbit/src/test/java/org/reactivecommons/async/utils/TestUtils.java @@ -1,6 +1,7 @@ package org.reactivecommons.async.utils; -import lombok.experimental.UtilityClass; +import lombok.AccessLevel; +import lombok.NoArgsConstructor; import reactor.core.publisher.Flux; import reactor.rabbitmq.AcknowledgableDelivery; import reactor.rabbitmq.ConsumeOptions; @@ -14,8 +15,8 @@ import static reactor.core.publisher.Flux.defer; -@UtilityClass -public class TestUtils { +@NoArgsConstructor(access = AccessLevel.PRIVATE) +public final class TestUtils { public static void instructSafeReceiverMock(final Receiver receiver, final Flux source) { final AtomicReference> sourceReference = new AtomicReference<>(source); diff --git a/build.gradle b/build.gradle index 4a898c00..669fdc4a 100644 --- a/build.gradle +++ b/build.gradle @@ -1,8 +1,8 @@ buildscript { repositories { mavenCentral() - maven { url 'https://repo.spring.io/milestone' } - maven { url 'https://repo.spring.io/snapshot' } + maven { url = 'https://repo.spring.io/milestone' } + maven { url = 'https://repo.spring.io/snapshot' } } dependencies { diff --git a/docs/docs/reactive-commons/2-sending-a-domain-event.md b/docs/docs/reactive-commons/2-sending-a-domain-event.md index 243e1a72..08cb8703 100644 --- a/docs/docs/reactive-commons/2-sending-a-domain-event.md +++ b/docs/docs/reactive-commons/2-sending-a-domain-event.md @@ -40,7 +40,7 @@ For example: @EnableDomainEventBus public class ReactiveEventsGateway { public static final String SOME_EVENT_NAME = "some.event.name"; - private final DomainEventBus domainEventBus; // Auto injectec bean created by the @EnableDomainEventBus annotation + private final DomainEventBus domainEventBus; // Auto injected bean created by the @EnableDomainEventBus annotation public Mono emit(Object event) { return Mono.from(domainEventBus.emit(new DomainEvent<>(SOME_EVENT_NAME, UUID.randomUUID().toString(), event))); diff --git a/docs/docs/reactive-commons/4-making-an-async-query.md b/docs/docs/reactive-commons/4-making-an-async-query.md index 6c1d15f5..a8f13541 100644 --- a/docs/docs/reactive-commons/4-making-an-async-query.md +++ b/docs/docs/reactive-commons/4-making-an-async-query.md @@ -52,7 +52,7 @@ For example: public class ReactiveDirectAsyncGateway { public static final String TARGET_NAME = "other-app";// refers to remote spring.application.name property public static final String SOME_QUERY_NAME = "some.query.name"; - private final DirectAsyncGateway gateway; // Auto injectec bean created by the @EnableDirectAsyncGateway annotation + private final DirectAsyncGateway gateway; // Auto injected bean created by the @EnableDirectAsyncGateway annotation public Mono requestForRemoteData(Object query/*change for proper model*/) { return gateway.requestReply(new AsyncQuery<>(SOME_QUERY_NAME, query), TARGET_NAME, Object.class/*change for proper model*/); diff --git a/docs/docs/reactive-commons/8-serving-async-queries.md b/docs/docs/reactive-commons/8-serving-async-queries.md index fc0fff41..f6b94b89 100644 --- a/docs/docs/reactive-commons/8-serving-async-queries.md +++ b/docs/docs/reactive-commons/8-serving-async-queries.md @@ -38,7 +38,7 @@ As the model of queries is direct, a consumer always can send queries to the ser ### Wildcards -You may need to handle variable querie names that have the same structure, in that case you can specfy a pattern with '*' wildcard, for example: +You may need to handle variable queries names that have the same structure, in that case you can specfy a pattern with '*' wildcard, for example: ```java @Configuration @@ -60,7 +60,7 @@ There is a concept introduced in queries that cannot be resolved locally and may - A consumer application called APP1 make an async query to an application called APP2 (with horizontal scaling). - an instance A of the APP2 receives the query and stores a reference to respond later. -- When response is fullfilled, an external source makes an HTTPS Call to an endpoint of an instance of APP2 but it can be diferent to the instance A, for example can be the instance B. +- When response is fulfilled, an external source makes an HTTPS Call to an endpoint of an instance of APP2 but it can be diferent to the instance A, for example can be the instance B. - The instance B of APP2 queries for the saved reference and uses DirectAsyncGateway to answer the pending query to the application APP1. This scenario can be resolved with ReactiveCommons by using the next resources: @@ -106,7 +106,7 @@ When some external source notifies our APP2 instance with the answer we should f @RequiredArgsConstructor @EnableDirectAsyncGateway public class ReactiveDirectAsyncGateway { - private final DirectAsyncGateway gateway; // Auto injectec bean created by the @EnableDirectAsyncGateway annotation + private final DirectAsyncGateway gateway; // Auto injected bean created by the @EnableDirectAsyncGateway annotation public Mono replyDelegate(String correlationId, Object response/*change for proper model*/) { return getReference(correlationId) diff --git a/docs/docs/reactive-commons/9-configuration-properties.md b/docs/docs/reactive-commons/9-configuration-properties.md index a0da9bd8..8baefe62 100644 --- a/docs/docs/reactive-commons/9-configuration-properties.md +++ b/docs/docs/reactive-commons/9-configuration-properties.md @@ -62,7 +62,7 @@ app: virtual-host: /accounts ``` -You can override this settings programmatically through a `AsyncPropsDomainProperties` bean. +You can override this settings programmatically through a `AsyncRabbitPropsDomainProperties` bean. ```java package sample; @@ -78,7 +78,7 @@ public class MyDomainConfig { @Bean @Primary - public AsyncPropsDomainProperties customDomainProperties() { + public AsyncRabbitPropsDomainProperties customDomainProperties() { RabbitProperties propertiesApp = new RabbitProperties(); propertiesApp.setHost("localhost"); propertiesApp.setPort(5672); @@ -93,7 +93,7 @@ public class MyDomainConfig { propertiesAccounts.setUsername("guest"); propertiesAccounts.setPassword("guest"); - return AsyncPropsDomainProperties.builder() + return AsyncRabbitPropsDomainProperties.builder() .withDomain("app", AsyncProps.builder() .connectionProperties(propertiesApp) .build()) diff --git a/docs/docs/scenarios/1-single-broker.md b/docs/docs/scenarios/1-single-broker.md index 1dbafcf7..ea4d7380 100644 --- a/docs/docs/scenarios/1-single-broker.md +++ b/docs/docs/scenarios/1-single-broker.md @@ -60,7 +60,7 @@ app: virtual-host: / ``` -You can override this settings programmatically through a `AsyncPropsDomainProperties` bean. +You can override this settings programmatically through a `AsyncRabbitPropsDomainProperties` bean. ```java package sample; @@ -76,7 +76,7 @@ public class MyDomainConfig { @Bean @Primary - public AsyncPropsDomainProperties customDomainProperties() { + public AsyncRabbitPropsDomainProperties customDomainProperties() { RabbitProperties propertiesApp = new RabbitProperties(); propertiesApp.setHost("localhost"); propertiesApp.setPort(5672); @@ -84,7 +84,7 @@ public class MyDomainConfig { propertiesApp.setUsername("guest"); propertiesApp.setPassword("guest"); - return AsyncPropsDomainProperties.builder() + return AsyncRabbitPropsDomainProperties.builder() .withDomain("app", AsyncProps.builder() .connectionProperties(propertiesApp) .build()) @@ -93,13 +93,13 @@ public class MyDomainConfig { } ``` -Additionally, if you want to set only connection properties you can use the `AsyncPropsDomain.SecretFiller` class. +Additionally, if you want to set only connection properties you can use the `AsyncPropsDomain.RabbitSecretFiller` class. ```java @Bean @Primary -public AsyncPropsDomain.SecretFiller customFiller() { +public AsyncPropsDomain.RabbitSecretFiller customFiller() { return (domain, asyncProps) -> { // customize asyncProps here by domain }; diff --git a/docs/docs/scenarios/2-two-brokers-same-type.md b/docs/docs/scenarios/2-two-brokers-same-type.md index 2874565a..4ff5045c 100644 --- a/docs/docs/scenarios/2-two-brokers-same-type.md +++ b/docs/docs/scenarios/2-two-brokers-same-type.md @@ -51,7 +51,7 @@ public HandlerRegistry handlerRegistrySubs(UseCase useCase) { ```java @Service -@AllArgsConstructor +@RequiredArgsConstructor public class SampleRestController { private final DirectAsyncGateway directAsyncGateway; @@ -126,7 +126,7 @@ app: virtual-host: /accounts ``` -You can override this settings programmatically through a `AsyncPropsDomainProperties` bean. +You can override this settings programmatically through a `AsyncRabbitPropsDomainProperties` bean. ```java package sample; @@ -142,7 +142,7 @@ public class MyDomainConfig { @Bean @Primary - public AsyncPropsDomainProperties customDomainProperties() { + public AsyncRabbitPropsDomainProperties customDomainProperties() { RabbitProperties propertiesApp = new RabbitProperties(); // this may be loaded from secrets propertiesApp.setHost("localhost"); propertiesApp.setPort(5672); @@ -157,7 +157,7 @@ public class MyDomainConfig { propertiesAccounts.setUsername("guest"); propertiesAccounts.setPassword("guest"); - return AsyncPropsDomainProperties.builder() + return AsyncRabbitPropsDomainProperties.builder() .withDomain("app", AsyncProps.builder() .connectionProperties(propertiesApp) .build()) diff --git a/domain/domain-events/src/main/java/org/reactivecommons/api/domain/Command.java b/domain/domain-events/src/main/java/org/reactivecommons/api/domain/Command.java index 35aa0c23..f61956b7 100644 --- a/domain/domain-events/src/main/java/org/reactivecommons/api/domain/Command.java +++ b/domain/domain-events/src/main/java/org/reactivecommons/api/domain/Command.java @@ -1,11 +1,11 @@ package org.reactivecommons.api.domain; -import lombok.AllArgsConstructor; import lombok.Data; +import lombok.RequiredArgsConstructor; @Data -@AllArgsConstructor +@RequiredArgsConstructor public class Command { private final String name; private final String commandId; diff --git a/domain/domain-events/src/main/java/org/reactivecommons/api/domain/DomainEvent.java b/domain/domain-events/src/main/java/org/reactivecommons/api/domain/DomainEvent.java index 23717f00..b9319690 100644 --- a/domain/domain-events/src/main/java/org/reactivecommons/api/domain/DomainEvent.java +++ b/domain/domain-events/src/main/java/org/reactivecommons/api/domain/DomainEvent.java @@ -1,10 +1,10 @@ package org.reactivecommons.api.domain; -import lombok.AllArgsConstructor; import lombok.Data; +import lombok.RequiredArgsConstructor; @Data -@AllArgsConstructor +@RequiredArgsConstructor public class DomainEvent { private final String name; private final String eventId; diff --git a/domain/domain-events/src/main/java/org/reactivecommons/api/domain/DomainEventBus.java b/domain/domain-events/src/main/java/org/reactivecommons/api/domain/DomainEventBus.java index 458a0c0c..0c62f8a8 100644 --- a/domain/domain-events/src/main/java/org/reactivecommons/api/domain/DomainEventBus.java +++ b/domain/domain-events/src/main/java/org/reactivecommons/api/domain/DomainEventBus.java @@ -5,8 +5,10 @@ public interface DomainEventBus { Publisher emit(DomainEvent event); + Publisher emit(String domain, DomainEvent event); Publisher emit(CloudEvent event); + Publisher emit(String domain, CloudEvent event); } diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index e2847c82..e18bc253 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.12.1-bin.zip networkTimeout=10000 validateDistributionUrl=true zipStoreBase=GRADLE_USER_HOME diff --git a/gradlew b/gradlew index f5feea6d..f3b75f3b 100755 --- a/gradlew +++ b/gradlew @@ -86,8 +86,7 @@ done # shellcheck disable=SC2034 APP_BASE_NAME=${0##*/} # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) -APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s -' "$PWD" ) || exit +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD=maximum diff --git a/main.gradle b/main.gradle index 66cffb97..4df770e4 100644 --- a/main.gradle +++ b/main.gradle @@ -2,13 +2,15 @@ allprojects { apply plugin: 'java' apply plugin: 'jacoco' - sourceCompatibility = JavaVersion.VERSION_11 - targetCompatibility = JavaVersion.VERSION_17 + java { + sourceCompatibility = JavaVersion.VERSION_11 + targetCompatibility = JavaVersion.VERSION_17 + } repositories { mavenCentral() - maven { url 'https://repo.spring.io/snapshot' } - maven { url 'https://repo.spring.io/milestone' } + maven { url = 'https://repo.spring.io/snapshot' } + maven { url = 'https://repo.spring.io/milestone' } } if (toPublish.split(',').contains(project.name) || project.name == rootProject.name) { @@ -31,7 +33,7 @@ allprojects { } } - group 'org.reactivecommons' + group = 'org.reactivecommons' } nexusPublishing { @@ -72,7 +74,7 @@ subprojects { test { useJUnitPlatform() - if (System.getProperty("env.ci").equals("true")) { + if (System.getProperty("env.ci") == "true") { systemProperty "env.ci", System.getProperty("env.ci") } @@ -88,7 +90,7 @@ subprojects { apply plugin: 'maven-publish' apply plugin: 'signing' - group groupId + group = groupId tasks.named("jar") { enabled = true @@ -176,5 +178,5 @@ tasks.register('generateMergedReport', JacocoReport) { } tasks.named('wrapper') { - gradleVersion = '8.11.1' + gradleVersion = '8.12.1' } \ No newline at end of file diff --git a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/ReactiveCommonsListenersConfig.java b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/ReactiveCommonsListenersConfig.java index 44cc8772..ba08c712 100644 --- a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/ReactiveCommonsListenersConfig.java +++ b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/ReactiveCommonsListenersConfig.java @@ -33,11 +33,15 @@ public DomainHandlers buildHandlers(ApplicationContext context, registries.put("primaryHandlerRegistry", primaryRegistry); } final Map props = context.getBeansOfType(GenericAsyncPropsDomain.class); - props.forEach((beanName, properties) -> properties.forEach((domain, asyncProps) -> { - String domainName = (String) domain; - HandlerResolver resolver = HandlerResolverBuilder.buildResolver(domainName, registries, commandHandler); - handlers.add(domainName, resolver); - })); + props.forEach((beanName, properties) -> properties + .forEach((domain, asyncProps) -> { + String domainName = (String) domain; + HandlerResolver resolver = HandlerResolverBuilder.buildResolver( + domainName, registries, commandHandler + ); + handlers.add(domainName, resolver); + }) + ); return handlers; } diff --git a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/health/RCHealth.java b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/health/RCHealth.java index 13972fc8..1c15a937 100644 --- a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/health/RCHealth.java +++ b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/health/RCHealth.java @@ -1,15 +1,15 @@ package org.reactivecommons.async.starter.config.health; -import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Getter; +import lombok.RequiredArgsConstructor; import java.util.HashMap; import java.util.Map; @Getter @Builder -@AllArgsConstructor +@RequiredArgsConstructor public class RCHealth { private final Status status; private final Map details; diff --git a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/health/RCHealthIndicator.java b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/health/RCHealthIndicator.java index 04cf1aec..da158e66 100644 --- a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/health/RCHealthIndicator.java +++ b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/health/RCHealthIndicator.java @@ -6,7 +6,9 @@ public abstract class RCHealthIndicator { public Mono health() { return doHealthCheck(RCHealth.builder()) - .onErrorResume(e -> Mono.just(RCHealth.builder().down().withDetail("error", e.getMessage()).build())); + .onErrorResume(e -> + Mono.just(RCHealth.builder().down().withDetail("error", e.getMessage()).build()) + ); } public abstract Mono doHealthCheck(RCHealth.RCHealthBuilder builder); diff --git a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/health/ReactiveCommonsHealthIndicator.java b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/health/ReactiveCommonsHealthIndicator.java index 6b316cc3..76178b28 100644 --- a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/health/ReactiveCommonsHealthIndicator.java +++ b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/health/ReactiveCommonsHealthIndicator.java @@ -1,6 +1,6 @@ package org.reactivecommons.async.starter.config.health; -import lombok.AllArgsConstructor; +import lombok.RequiredArgsConstructor; import lombok.extern.log4j.Log4j2; import org.reactivecommons.async.starter.broker.BrokerProvider; import org.reactivecommons.async.starter.config.ConnectionManager; @@ -10,7 +10,7 @@ import reactor.core.publisher.Mono; @Log4j2 -@AllArgsConstructor +@RequiredArgsConstructor public class ReactiveCommonsHealthIndicator extends AbstractReactiveHealthIndicator { public static final String DOMAIN = "domain"; public static final String VERSION = "version"; @@ -21,7 +21,9 @@ public class ReactiveCommonsHealthIndicator extends AbstractReactiveHealthIndica protected Mono doHealthCheck(Health.Builder builder) { return Flux.fromIterable(manager.getProviders().values()) .flatMap(BrokerProvider::healthCheck) - .reduceWith(Health::up, (health, status) -> reduceHealth((Health.Builder) health, (RCHealth) status)) + .reduceWith(Health::up, (health, status) -> + reduceHealth((Health.Builder) health, (RCHealth) status) + ) .map(b -> ((Health.Builder) b).build()); } diff --git a/starters/async-commons-starter/src/test/java/org/reactivecommons/async/starter/mybroker/MyBrokerProvider.java b/starters/async-commons-starter/src/test/java/org/reactivecommons/async/starter/mybroker/MyBrokerProvider.java index 57f27e66..28a86de0 100644 --- a/starters/async-commons-starter/src/test/java/org/reactivecommons/async/starter/mybroker/MyBrokerProvider.java +++ b/starters/async-commons-starter/src/test/java/org/reactivecommons/async/starter/mybroker/MyBrokerProvider.java @@ -1,6 +1,6 @@ package org.reactivecommons.async.starter.mybroker; -import lombok.AllArgsConstructor; +import lombok.RequiredArgsConstructor; import org.reactivecommons.api.domain.DomainEventBus; import org.reactivecommons.async.api.DirectAsyncGateway; import org.reactivecommons.async.commons.HandlerResolver; @@ -10,7 +10,7 @@ import org.reactivecommons.async.starter.mybroker.props.MyBrokerAsyncProps; import reactor.core.publisher.Mono; -@AllArgsConstructor +@RequiredArgsConstructor public class MyBrokerProvider implements BrokerProvider { private final String domain; private final MyBrokerAsyncProps props; diff --git a/starters/async-commons-starter/src/test/java/org/reactivecommons/async/starter/props/GenericAsyncPropsDomainTest.java b/starters/async-commons-starter/src/test/java/org/reactivecommons/async/starter/props/GenericAsyncPropsDomainTest.java index 8e4dac67..b69b8fde 100644 --- a/starters/async-commons-starter/src/test/java/org/reactivecommons/async/starter/props/GenericAsyncPropsDomainTest.java +++ b/starters/async-commons-starter/src/test/java/org/reactivecommons/async/starter/props/GenericAsyncPropsDomainTest.java @@ -30,8 +30,9 @@ void shouldCreateProps() { configured.put(OTHER, other); MyBrokerSecretFiller secretFiller = (domain, props) -> { }; - MyBrokerAsyncPropsDomain propsDomain = new MyBrokerAsyncPropsDomain(defaultAppName, defaultMyBrokerProps, configured, - secretFiller); + MyBrokerAsyncPropsDomain propsDomain = new MyBrokerAsyncPropsDomain( + defaultAppName, defaultMyBrokerProps, configured, secretFiller + ); // Act MyBrokerAsyncProps props = propsDomain.getProps(DEFAULT_DOMAIN); MyBrokerAsyncProps otherProps = propsDomain.getProps(OTHER); @@ -49,7 +50,9 @@ void shouldCreatePropsWithDefaultConnectionProperties() { MyBrokerAsyncProps propsConfigured = new MyBrokerAsyncProps(); MyBrokerAsyncPropsDomain propsDomain = MyBrokerAsyncPropsDomain.builder(MyBrokerConnProps.class, AsyncMyBrokerPropsDomainProperties.class, - (Constructor) MyBrokerAsyncPropsDomain.class.getDeclaredConstructors()[0]) + (Constructor) MyBrokerAsyncPropsDomain.class + .getDeclaredConstructors()[0] + ) .withDefaultAppName(defaultAppName) .withDefaultProperties(defaultMyBrokerProps) .withDomain(DEFAULT_DOMAIN, propsConfigured) diff --git a/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaBrokerProvider.java b/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaBrokerProvider.java index f5d04458..3a022754 100644 --- a/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaBrokerProvider.java +++ b/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaBrokerProvider.java @@ -1,8 +1,8 @@ package org.reactivecommons.async.kafka; import io.micrometer.core.instrument.MeterRegistry; -import lombok.AllArgsConstructor; import lombok.Getter; +import lombok.RequiredArgsConstructor; import org.reactivecommons.api.domain.DomainEventBus; import org.reactivecommons.async.api.DirectAsyncGateway; import org.reactivecommons.async.commons.DiscardNotifier; @@ -24,7 +24,7 @@ import reactor.core.publisher.Mono; @Getter -@AllArgsConstructor +@RequiredArgsConstructor public class KafkaBrokerProvider implements BrokerProvider { private final String domain; private final AsyncKafkaProps props; diff --git a/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaBrokerProviderFactory.java b/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaBrokerProviderFactory.java index 0c06949a..d6ebece4 100644 --- a/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaBrokerProviderFactory.java +++ b/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaBrokerProviderFactory.java @@ -1,7 +1,7 @@ package org.reactivecommons.async.kafka; import io.micrometer.core.instrument.MeterRegistry; -import lombok.AllArgsConstructor; +import lombok.RequiredArgsConstructor; import org.apache.kafka.clients.admin.AdminClient; import org.reactivecommons.async.commons.DiscardNotifier; import org.reactivecommons.async.commons.ext.CustomReporter; @@ -20,7 +20,7 @@ import org.springframework.stereotype.Service; @Service("kafka") -@AllArgsConstructor +@RequiredArgsConstructor public class KafkaBrokerProviderFactory implements BrokerProviderFactory { private final ReactiveReplyRouter router; private final KafkaJacksonMessageConverter converter; @@ -40,7 +40,8 @@ public DiscardProvider getDiscardProvider(AsyncKafkaProps props) { } @Override - public BrokerProvider getProvider(String domain, AsyncKafkaProps props, DiscardProvider discardProvider) { + public BrokerProvider getProvider(String domain, AsyncKafkaProps props, + DiscardProvider discardProvider) { TopologyCreator creator = KafkaSetupUtils.createTopologyCreator(props, customizations, sslBundles); ReactiveMessageSender sender = KafkaSetupUtils.createMessageSender(props, converter, creator, sslBundles); ReactiveMessageListener listener = KafkaSetupUtils.createMessageListener(props, sslBundles); diff --git a/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaDiscardProvider.java b/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaDiscardProvider.java index 11307a8b..7ac62293 100644 --- a/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaDiscardProvider.java +++ b/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaDiscardProvider.java @@ -1,6 +1,6 @@ package org.reactivecommons.async.kafka; -import lombok.AllArgsConstructor; +import lombok.RequiredArgsConstructor; import org.reactivecommons.async.commons.DiscardNotifier; import org.reactivecommons.async.commons.converters.MessageConverter; import org.reactivecommons.async.kafka.communications.ReactiveMessageSender; @@ -13,7 +13,7 @@ import java.util.Map; import java.util.concurrent.ConcurrentHashMap; -@AllArgsConstructor +@RequiredArgsConstructor public class KafkaDiscardProvider implements DiscardProvider { private final AsyncKafkaProps props; private final MessageConverter converter; diff --git a/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaSetupUtils.java b/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaSetupUtils.java index c6670307..2912d72b 100644 --- a/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaSetupUtils.java +++ b/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/KafkaSetupUtils.java @@ -1,6 +1,7 @@ package org.reactivecommons.async.kafka; -import lombok.experimental.UtilityClass; +import lombok.AccessLevel; +import lombok.NoArgsConstructor; import org.apache.kafka.clients.admin.AdminClient; import org.apache.kafka.common.serialization.ByteArrayDeserializer; import org.apache.kafka.common.serialization.ByteArraySerializer; @@ -25,8 +26,8 @@ import java.nio.file.Path; import java.util.Map; -@UtilityClass -public class KafkaSetupUtils { +@NoArgsConstructor(access = AccessLevel.PRIVATE) +public final class KafkaSetupUtils { public static DiscardNotifier createDiscardNotifier(ReactiveMessageSender sender, MessageConverter converter) { return new DLQDiscardNotifier(new KafkaDomainEventBus(sender), converter); @@ -52,7 +53,9 @@ public static ReactiveMessageListener createMessageListener(AsyncKafkaProps conf KafkaProperties props = config.getConnectionProperties(); props.getConsumer().setKeyDeserializer(StringDeserializer.class); props.getConsumer().setValueDeserializer(ByteArrayDeserializer.class); - ReceiverOptions receiverOptions = ReceiverOptions.create(props.buildConsumerProperties(sslBundles)); + ReceiverOptions receiverOptions = ReceiverOptions.create( + props.buildConsumerProperties(sslBundles) + ); return new ReactiveMessageListener(receiverOptions); } @@ -81,6 +84,7 @@ public static KafkaProperties readPropsFromDotEnv(Path path) throws IOException } public static String jassConfig(String username, String password) { - return String.format("org.apache.kafka.common.security.plain.PlainLoginModule required username=\"%s\" password=\"%s\";", username, password); + return String.format("org.apache.kafka.common.security.plain.PlainLoginModule required " + + "username=\"%s\" password=\"%s\";", username, password); } } diff --git a/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/config/props/AsyncKafkaProps.java b/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/config/props/AsyncKafkaProps.java index 55919f1e..26eefb03 100644 --- a/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/config/props/AsyncKafkaProps.java +++ b/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/config/props/AsyncKafkaProps.java @@ -19,6 +19,7 @@ public class AsyncKafkaProps extends GenericAsyncProps { @NestedConfigurationProperty + @Builder.Default private KafkaProperties connectionProperties = new KafkaProperties(); @NestedConfigurationProperty diff --git a/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/health/KafkaReactiveHealthIndicator.java b/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/health/KafkaReactiveHealthIndicator.java index ed49de49..2241f3c2 100644 --- a/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/health/KafkaReactiveHealthIndicator.java +++ b/starters/async-kafka-starter/src/main/java/org/reactivecommons/async/kafka/health/KafkaReactiveHealthIndicator.java @@ -1,6 +1,6 @@ package org.reactivecommons.async.kafka.health; -import lombok.AllArgsConstructor; +import lombok.RequiredArgsConstructor; import lombok.extern.log4j.Log4j2; import org.apache.kafka.clients.admin.AdminClient; import org.reactivecommons.async.starter.config.health.RCHealth; @@ -11,7 +11,7 @@ import static org.reactivecommons.async.starter.config.health.ReactiveCommonsHealthIndicator.VERSION; @Log4j2 -@AllArgsConstructor +@RequiredArgsConstructor public class KafkaReactiveHealthIndicator extends RCHealthIndicator { private final String domain; private final AdminClient adminClient; diff --git a/starters/async-rabbit-standalone/src/main/java/org/reactivecommons/async/rabbit/standalone/config/DirectAsyncGatewayConfig.java b/starters/async-rabbit-standalone/src/main/java/org/reactivecommons/async/rabbit/standalone/config/DirectAsyncGatewayConfig.java index 2e4ac2ee..0beea22f 100644 --- a/starters/async-rabbit-standalone/src/main/java/org/reactivecommons/async/rabbit/standalone/config/DirectAsyncGatewayConfig.java +++ b/starters/async-rabbit-standalone/src/main/java/org/reactivecommons/async/rabbit/standalone/config/DirectAsyncGatewayConfig.java @@ -1,7 +1,7 @@ package org.reactivecommons.async.rabbit.standalone.config; import io.micrometer.core.instrument.MeterRegistry; -import lombok.AllArgsConstructor; +import lombok.RequiredArgsConstructor; import org.reactivecommons.async.commons.config.BrokerConfig; import org.reactivecommons.async.commons.converters.MessageConverter; import org.reactivecommons.async.commons.reply.ReactiveReplyRouter; @@ -14,7 +14,7 @@ import java.util.Base64; import java.util.UUID; -@AllArgsConstructor +@RequiredArgsConstructor public class DirectAsyncGatewayConfig { private String directMessagesExchangeName; diff --git a/starters/async-rabbit-standalone/src/main/java/org/reactivecommons/async/rabbit/standalone/config/EventBusConfig.java b/starters/async-rabbit-standalone/src/main/java/org/reactivecommons/async/rabbit/standalone/config/EventBusConfig.java index d158d48c..959e19d9 100644 --- a/starters/async-rabbit-standalone/src/main/java/org/reactivecommons/async/rabbit/standalone/config/EventBusConfig.java +++ b/starters/async-rabbit-standalone/src/main/java/org/reactivecommons/async/rabbit/standalone/config/EventBusConfig.java @@ -1,18 +1,17 @@ package org.reactivecommons.async.rabbit.standalone.config; +import lombok.RequiredArgsConstructor; import org.reactivecommons.api.domain.DomainEventBus; import org.reactivecommons.async.rabbit.RabbitDomainEventBus; import org.reactivecommons.async.rabbit.communications.ReactiveMessageSender; import static reactor.rabbitmq.ExchangeSpecification.exchange; -public class EventBusConfig { - private String domainEventsExchangeName; +@RequiredArgsConstructor +public class EventBusConfig { - public EventBusConfig(String domainEventsExchangeName) { - this.domainEventsExchangeName = domainEventsExchangeName; - } + private final String domainEventsExchangeName; public DomainEventBus domainEventBus(ReactiveMessageSender sender) { sender.getTopologyCreator().declare(exchange(domainEventsExchangeName).durable(true).type("topic")).subscribe(); diff --git a/starters/async-rabbit-standalone/src/main/java/org/reactivecommons/async/rabbit/standalone/config/RabbitMqConfig.java b/starters/async-rabbit-standalone/src/main/java/org/reactivecommons/async/rabbit/standalone/config/RabbitMqConfig.java index f12d3eaf..2ee716e6 100644 --- a/starters/async-rabbit-standalone/src/main/java/org/reactivecommons/async/rabbit/standalone/config/RabbitMqConfig.java +++ b/starters/async-rabbit-standalone/src/main/java/org/reactivecommons/async/rabbit/standalone/config/RabbitMqConfig.java @@ -2,6 +2,7 @@ import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; +import lombok.RequiredArgsConstructor; import lombok.extern.java.Log; import org.reactivecommons.async.commons.converters.MessageConverter; import org.reactivecommons.async.commons.converters.json.ObjectMapperSupplier; @@ -22,13 +23,10 @@ import java.util.logging.Level; @Log +@RequiredArgsConstructor public class RabbitMqConfig { - private String appName; - - public RabbitMqConfig(String appName) { - this.appName = appName; - } + private final String appName; public ReactiveMessageSender messageSender(ConnectionFactoryProvider provider, MessageConverter converter, RabbitProperties rabbitProperties) { @@ -63,9 +61,9 @@ public MessageConverter messageConverter(ObjectMapperSupplier objectMapperSuppli Mono createSenderConnectionMono(ConnectionFactory factory, String name) { return Mono.fromCallable(() -> factory.newConnection(name)) - .doOnError(err -> - log.log(Level.SEVERE, "Error creating connection to RabbitMq Broker. Starting retry process...", err) - ) + .doOnError(err -> log.log( + Level.SEVERE, "Error creating connection to RabbitMq Broker. Starting retry process...", err + )) .retryWhen(Retry.backoff(Long.MAX_VALUE, Duration.ofMillis(300))) .cache(); } diff --git a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQBrokerProvider.java b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQBrokerProvider.java index 3abf1e90..0ec7bc89 100644 --- a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQBrokerProvider.java +++ b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQBrokerProvider.java @@ -1,8 +1,8 @@ package org.reactivecommons.async.rabbit; import io.micrometer.core.instrument.MeterRegistry; -import lombok.AllArgsConstructor; import lombok.Getter; +import lombok.RequiredArgsConstructor; import lombok.extern.java.Log; import org.reactivecommons.api.domain.DomainEventBus; import org.reactivecommons.async.api.DirectAsyncGateway; @@ -29,7 +29,7 @@ @Log @Getter -@AllArgsConstructor +@RequiredArgsConstructor public class RabbitMQBrokerProvider implements BrokerProvider { private final String domain; private final AsyncProps props; @@ -143,12 +143,12 @@ public void listenQueries(HandlerResolver resolver) { @Override public void listenReplies() { if (props.isListenReplies()) { - final ApplicationReplyListener replyListener = - new ApplicationReplyListener(router, - receiver, - props.getBrokerConfigProps().getReplyQueue(), - props.getBrokerConfigProps().getGlobalReplyExchangeName(), - props.getCreateTopology()); + final ApplicationReplyListener replyListener = new ApplicationReplyListener(router, + receiver, + props.getBrokerConfigProps().getReplyQueue(), + props.getBrokerConfigProps().getGlobalReplyExchangeName(), + props.getCreateTopology() + ); replyListener.startListening(config.getRoutingKey()); } } diff --git a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQBrokerProviderFactory.java b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQBrokerProviderFactory.java index 8c81db82..1dd5fb9f 100644 --- a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQBrokerProviderFactory.java +++ b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQBrokerProviderFactory.java @@ -1,7 +1,7 @@ package org.reactivecommons.async.rabbit; import io.micrometer.core.instrument.MeterRegistry; -import lombok.AllArgsConstructor; +import lombok.RequiredArgsConstructor; import org.reactivecommons.async.commons.DiscardNotifier; import org.reactivecommons.async.commons.config.BrokerConfig; import org.reactivecommons.async.commons.ext.CustomReporter; @@ -19,7 +19,7 @@ import org.springframework.stereotype.Service; @Service("rabbitmq") -@AllArgsConstructor +@RequiredArgsConstructor public class RabbitMQBrokerProviderFactory implements BrokerProviderFactory { private final BrokerConfig config; private final ReactiveReplyRouter router; diff --git a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQDiscardProvider.java b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQDiscardProvider.java index 36615c4e..9db580c3 100644 --- a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQDiscardProvider.java +++ b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQDiscardProvider.java @@ -1,6 +1,6 @@ package org.reactivecommons.async.rabbit; -import lombok.AllArgsConstructor; +import lombok.RequiredArgsConstructor; import org.reactivecommons.async.commons.DiscardNotifier; import org.reactivecommons.async.commons.config.BrokerConfig; import org.reactivecommons.async.commons.converters.MessageConverter; @@ -13,7 +13,7 @@ import java.util.Map; import java.util.concurrent.ConcurrentHashMap; -@AllArgsConstructor +@RequiredArgsConstructor public class RabbitMQDiscardProvider implements DiscardProvider { private final AsyncProps props; private final BrokerConfig config; diff --git a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQSetupUtils.java b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQSetupUtils.java index 18be2b17..40142e83 100644 --- a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQSetupUtils.java +++ b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/RabbitMQSetupUtils.java @@ -2,8 +2,9 @@ import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; +import lombok.AccessLevel; +import lombok.NoArgsConstructor; import lombok.SneakyThrows; -import lombok.experimental.UtilityClass; import lombok.extern.java.Log; import org.reactivecommons.api.domain.DomainEventBus; import org.reactivecommons.async.commons.DLQDiscardNotifier; @@ -51,8 +52,8 @@ import java.util.logging.Level; @Log -@UtilityClass -public class RabbitMQSetupUtils { +@NoArgsConstructor(access = AccessLevel.PRIVATE) +public final class RabbitMQSetupUtils { private static final String LISTENER_TYPE = "listener"; private static final String SENDER_TYPE = "sender"; private static final String DEFAULT_PROTOCOL; @@ -180,7 +181,7 @@ private static void setUpSSL(ConnectionFactory factory, RabbitProperties propert logDetails(trustManagers); - if (ssl.getVerifyHostname()) { + if (ssl.isVerifyHostname()) { factory.enableHostnameVerification(); } } diff --git a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/config/props/AsyncRabbitPropsDomainProperties.java b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/config/props/AsyncRabbitPropsDomainProperties.java index b852a0db..44fe7f0a 100644 --- a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/config/props/AsyncRabbitPropsDomainProperties.java +++ b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/config/props/AsyncRabbitPropsDomainProperties.java @@ -1,18 +1,16 @@ package org.reactivecommons.async.rabbit.config.props; +import lombok.NoArgsConstructor; import org.reactivecommons.async.rabbit.config.RabbitProperties; import org.reactivecommons.async.starter.props.GenericAsyncPropsDomainProperties; import org.springframework.boot.context.properties.ConfigurationProperties; import java.util.Map; +@NoArgsConstructor @ConfigurationProperties(prefix = "app.async") public class AsyncRabbitPropsDomainProperties extends GenericAsyncPropsDomainProperties { - - public AsyncRabbitPropsDomainProperties() { - } - public AsyncRabbitPropsDomainProperties(Map m) { super(m); } diff --git a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/config/props/BrokerConfigProps.java b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/config/props/BrokerConfigProps.java index 735e4e2e..32ffd8c7 100644 --- a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/config/props/BrokerConfigProps.java +++ b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/config/props/BrokerConfigProps.java @@ -68,9 +68,8 @@ private String resolveTemporaryQueue(AtomicReference property, String su final String replyName = generateNameFrom(getAppName(), suffix); if (property.compareAndSet(null, replyName)) { return replyName; - } else { - return property.get(); } + return property.get(); } return name; } diff --git a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/config/spring/RabbitPropertiesBase.java b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/config/spring/RabbitPropertiesBase.java index 41346510..19d0c341 100644 --- a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/config/spring/RabbitPropertiesBase.java +++ b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/config/spring/RabbitPropertiesBase.java @@ -1,5 +1,7 @@ package org.reactivecommons.async.rabbit.config.spring; +import lombok.Getter; +import lombok.Setter; import org.springframework.boot.convert.DurationUnit; import org.springframework.util.CollectionUtils; import org.springframework.util.StringUtils; @@ -14,78 +16,96 @@ public class RabbitPropertiesBase { /** * RabbitMQ host. */ + @Setter + @Getter private String host = "localhost"; /** * RabbitMQ port. */ + @Setter + @Getter private int port = 5672; /** * Login user to authenticate to the communications. */ + @Setter + @Getter private String username = "guest"; /** * Login to authenticate against the communications. */ + @Setter + @Getter private String password = "guest"; //NOSONAR /** * SSL configuration. */ + @Getter private final Ssl ssl = new Ssl(); /** * Virtual host to use when connecting to the communications. */ + @Getter private String virtualHost; /** * Comma-separated list of addresses to which the client should connect. */ + @Getter private String addresses; /** * Requested heartbeat timeout; zero for none. If a duration suffix is not specified, * seconds will be used. */ + @Getter + @Setter @DurationUnit(ChronoUnit.SECONDS) private Duration requestedHeartbeat; /** * Whether to enable publisher confirms. */ + @Setter + @Getter private boolean publisherConfirms; /** * Whether to enable publisher returns. */ + @Setter + @Getter private boolean publisherReturns; /** * Connection timeout. Set it to zero to wait forever. */ + @Getter + @Setter private Duration connectionTimeout; /** * Cache configuration. */ + @Getter private final Cache cache = new Cache(); /** * Listener container configuration. */ + @Getter private final Listener listener = new Listener(); + @Getter private final Template template = new Template(); private List
parsedAddresses; - public String getHost() { - return this.host; - } - /** * Returns the host from the first address, or the configured host if no addresses * have been set. @@ -101,14 +121,6 @@ public String determineHost() { return this.parsedAddresses.get(0).host; } - public void setHost(String host) { - this.host = host; - } - - public int getPort() { - return this.port; - } - /** * Returns the port from the first address, or the configured port if no addresses * have been set. @@ -125,14 +137,6 @@ public int determinePort() { return address.port; } - public void setPort(int port) { - this.port = port; - } - - public String getAddresses() { - return this.addresses; - } - /** * Returns the comma-separated addresses or a single address ({@code host:port}) * created from the configured host and port if no addresses have been set. @@ -163,10 +167,6 @@ private List
parseAddresses(String addresses) { return parsedAddressesLocal; } - public String getUsername() { - return this.username; - } - /** * If addresses have been set and the first address has a username it is returned. * Otherwise returns the result of calling {@code getUsername()}. @@ -183,14 +183,6 @@ public String determineUsername() { return (address.username != null) ? address.username : this.username; } - public void setUsername(String username) { - this.username = username; - } - - public String getPassword() { - return this.password; - } - /** * If addresses have been set and the first address has a password it is returned. * Otherwise returns the result of calling {@code getPassword()}. @@ -207,18 +199,6 @@ public String determinePassword() { return (address.password != null) ? address.password : getPassword(); } - public void setPassword(String password) { - this.password = password; - } - - public Ssl getSsl() { - return this.ssl; - } - - public String getVirtualHost() { - return this.virtualHost; - } - /** * If addresses have been set and the first address has a virtual host it is returned. * Otherwise returns the result of calling {@code getVirtualHost()}. @@ -239,50 +219,8 @@ public void setVirtualHost(String virtualHost) { this.virtualHost = "".equals(virtualHost) ? "/" : virtualHost; } - public Duration getRequestedHeartbeat() { - return this.requestedHeartbeat; - } - - public void setRequestedHeartbeat(Duration requestedHeartbeat) { - this.requestedHeartbeat = requestedHeartbeat; - } - - public boolean isPublisherConfirms() { - return this.publisherConfirms; - } - - public void setPublisherConfirms(boolean publisherConfirms) { - this.publisherConfirms = publisherConfirms; - } - - public boolean isPublisherReturns() { - return this.publisherReturns; - } - - public void setPublisherReturns(boolean publisherReturns) { - this.publisherReturns = publisherReturns; - } - - public Duration getConnectionTimeout() { - return this.connectionTimeout; - } - - public void setConnectionTimeout(Duration connectionTimeout) { - this.connectionTimeout = connectionTimeout; - } - - public Cache getCache() { - return this.cache; - } - - public Listener getListener() { - return this.listener; - } - - public Template getTemplate() { - return this.template; - } - + @Getter + @Setter public static class Ssl { /** @@ -335,102 +273,17 @@ public static class Ssl { */ private boolean verifyHostname = true; - public boolean isEnabled() { - return this.enabled; - } - - public void setEnabled(boolean enabled) { - this.enabled = enabled; - } - - public String getKeyStore() { - return this.keyStore; - } - - public void setKeyStore(String keyStore) { - this.keyStore = keyStore; - } - - public String getKeyStoreType() { - return this.keyStoreType; - } - - public void setKeyStoreType(String keyStoreType) { - this.keyStoreType = keyStoreType; - } - - public String getKeyStorePassword() { - return this.keyStorePassword; - } - - public void setKeyStorePassword(String keyStorePassword) { - this.keyStorePassword = keyStorePassword; - } - - public String getTrustStore() { - return this.trustStore; - } - - public void setTrustStore(String trustStore) { - this.trustStore = trustStore; - } - - public String getTrustStoreType() { - return this.trustStoreType; - } - - public void setTrustStoreType(String trustStoreType) { - this.trustStoreType = trustStoreType; - } - - public String getTrustStorePassword() { - return this.trustStorePassword; - } - - public void setTrustStorePassword(String trustStorePassword) { - this.trustStorePassword = trustStorePassword; - } - - public String getAlgorithm() { - return this.algorithm; - } - - public void setAlgorithm(String sslAlgorithm) { - this.algorithm = sslAlgorithm; - } - - public boolean isValidateServerCertificate() { - return this.validateServerCertificate; - } - - public void setValidateServerCertificate(boolean validateServerCertificate) { - this.validateServerCertificate = validateServerCertificate; - } - - public boolean getVerifyHostname() { - return this.verifyHostname; - } - - public void setVerifyHostname(boolean verifyHostname) { - this.verifyHostname = verifyHostname; - } - } + @Getter public static class Cache { private final Channel channel = new Channel(); private final Connection connection = new Connection(); - public Channel getChannel() { - return this.channel; - } - - public Connection getConnection() { - return this.connection; - } - + @Getter + @Setter public static class Channel { /** @@ -445,24 +298,10 @@ public static class Channel { */ private Duration checkoutTimeout; - public Integer getSize() { - return this.size; - } - - public void setSize(Integer size) { - this.size = size; - } - - public Duration getCheckoutTimeout() { - return this.checkoutTimeout; - } - - public void setCheckoutTimeout(Duration checkoutTimeout) { - this.checkoutTimeout = checkoutTimeout; - } - } + @Getter + @Setter public static class Connection { /** @@ -475,22 +314,6 @@ public static class Connection { */ private Integer size; - public String getMode() { - return this.mode; - } - - public void setMode(String mode) { - this.mode = mode; - } - - public Integer getSize() { - return this.size; - } - - public void setSize(Integer size) { - this.size = size; - } - } } @@ -510,6 +333,9 @@ public enum ContainerType { } + + @Getter + @Setter public static class Listener { /** @@ -521,24 +347,10 @@ public static class Listener { private final DirectContainer direct = new DirectContainer(); - public ContainerType getType() { - return this.type; - } - - public void setType(ContainerType containerType) { - this.type = containerType; - } - - public SimpleContainer getSimple() { - return this.simple; - } - - public DirectContainer getDirect() { - return this.direct; - } - } + @Getter + @Setter public abstract static class AmqpContainer { /** @@ -572,57 +384,16 @@ public abstract static class AmqpContainer { */ private final ListenerRetry retry = new ListenerRetry(); - public boolean isAutoStartup() { - return this.autoStartup; - } - - public void setAutoStartup(boolean autoStartup) { - this.autoStartup = autoStartup; - } - - public Integer getAcknowledgeMode() { - return this.acknowledgeMode; - } - - public void setAcknowledgeMode(Integer acknowledgeMode) { - this.acknowledgeMode = acknowledgeMode; - } - - public Integer getPrefetch() { - return this.prefetch; - } - - public void setPrefetch(Integer prefetch) { - this.prefetch = prefetch; - } - - public Boolean getDefaultRequeueRejected() { - return this.defaultRequeueRejected; - } - - public void setDefaultRequeueRejected(Boolean defaultRequeueRejected) { - this.defaultRequeueRejected = defaultRequeueRejected; - } - - public Duration getIdleEventInterval() { - return this.idleEventInterval; - } - - public void setIdleEventInterval(Duration idleEventInterval) { - this.idleEventInterval = idleEventInterval; - } public abstract boolean isMissingQueuesFatal(); - public ListenerRetry getRetry() { - return this.retry; - } - } /** * Configuration properties for {@code SimpleMessageListenerContainer}. */ + @Getter + @Setter public static class SimpleContainer extends AmqpContainer { /** @@ -648,44 +419,13 @@ public static class SimpleContainer extends AmqpContainer { */ private boolean missingQueuesFatal = true; - public Integer getConcurrency() { - return this.concurrency; - } - - public void setConcurrency(Integer concurrency) { - this.concurrency = concurrency; - } - - public Integer getMaxConcurrency() { - return this.maxConcurrency; - } - - public void setMaxConcurrency(Integer maxConcurrency) { - this.maxConcurrency = maxConcurrency; - } - - public Integer getTransactionSize() { - return this.transactionSize; - } - - public void setTransactionSize(Integer transactionSize) { - this.transactionSize = transactionSize; - } - - @Override - public boolean isMissingQueuesFatal() { - return this.missingQueuesFatal; - } - - public void setMissingQueuesFatal(boolean missingQueuesFatal) { - this.missingQueuesFatal = missingQueuesFatal; - } - } /** * Configuration properties for {@code DirectMessageListenerContainer}. */ + @Getter + @Setter public static class DirectContainer extends AmqpContainer { /** @@ -699,25 +439,10 @@ public static class DirectContainer extends AmqpContainer { */ private boolean missingQueuesFatal = false; - public Integer getConsumersPerQueue() { - return this.consumersPerQueue; - } - - public void setConsumersPerQueue(Integer consumersPerQueue) { - this.consumersPerQueue = consumersPerQueue; - } - - @Override - public boolean isMissingQueuesFatal() { - return this.missingQueuesFatal; - } - - public void setMissingQueuesFatal(boolean missingQueuesFatal) { - this.missingQueuesFatal = missingQueuesFatal; - } - } + @Getter + @Setter public static class Template { private final Retry retry = new Retry(); @@ -753,60 +478,10 @@ public static class Template { */ private String queue; - public Retry getRetry() { - return this.retry; - } - - public Boolean getMandatory() { - return this.mandatory; - } - - public void setMandatory(Boolean mandatory) { - this.mandatory = mandatory; - } - - public Duration getReceiveTimeout() { - return this.receiveTimeout; - } - - public void setReceiveTimeout(Duration receiveTimeout) { - this.receiveTimeout = receiveTimeout; - } - - public Duration getReplyTimeout() { - return this.replyTimeout; - } - - public void setReplyTimeout(Duration replyTimeout) { - this.replyTimeout = replyTimeout; - } - - public String getExchange() { - return this.exchange; - } - - public void setExchange(String exchange) { - this.exchange = exchange; - } - - public String getRoutingKey() { - return this.routingKey; - } - - public void setRoutingKey(String routingKey) { - this.routingKey = routingKey; - } - - public String getQueue() { - return this.queue; - } - - public void setQueue(String queue) { - this.queue = queue; - } - } + @Getter + @Setter public static class Retry { /** @@ -834,63 +509,16 @@ public static class Retry { */ private Duration maxInterval = Duration.ofMillis(10000); - public boolean isEnabled() { - return this.enabled; - } - - public void setEnabled(boolean enabled) { - this.enabled = enabled; - } - - public int getMaxAttempts() { - return this.maxAttempts; - } - - public void setMaxAttempts(int maxAttempts) { - this.maxAttempts = maxAttempts; - } - - public Duration getInitialInterval() { - return this.initialInterval; - } - - public void setInitialInterval(Duration initialInterval) { - this.initialInterval = initialInterval; - } - - public double getMultiplier() { - return this.multiplier; - } - - public void setMultiplier(double multiplier) { - this.multiplier = multiplier; - } - - public Duration getMaxInterval() { - return this.maxInterval; - } - - public void setMaxInterval(Duration maxInterval) { - this.maxInterval = maxInterval; - } - } + @Getter + @Setter public static class ListenerRetry extends Retry { /** * Whether retries are stateless or stateful. */ private boolean stateless = true; - - public boolean isStateless() { - return this.stateless; - } - - public void setStateless(boolean stateless) { - this.stateless = stateless; - } - } private static final class Address { @@ -960,7 +588,7 @@ private void parseHostAndPort(String input) { this.port = DEFAULT_PORT; } else { this.host = input.substring(0, portIndex); - this.port = Integer.valueOf(input.substring(portIndex + 1)); + this.port = Integer.parseInt(input.substring(portIndex + 1)); } } diff --git a/starters/async-rabbit-starter/src/test/java/org/reactivecommons/async/rabbit/RabbitMQBrokerProviderTest.java b/starters/async-rabbit-starter/src/test/java/org/reactivecommons/async/rabbit/RabbitMQBrokerProviderTest.java index 5ea55767..3d12dc97 100644 --- a/starters/async-rabbit-starter/src/test/java/org/reactivecommons/async/rabbit/RabbitMQBrokerProviderTest.java +++ b/starters/async-rabbit-starter/src/test/java/org/reactivecommons/async/rabbit/RabbitMQBrokerProviderTest.java @@ -95,7 +95,8 @@ public void init() { @Test void shouldCreateDomainEventBus() { when(sender.getTopologyCreator()).thenReturn(creator); - when(creator.declare(any(ExchangeSpecification.class))).thenReturn(Mono.just(mock(AMQP.Exchange.DeclareOk.class))); + when(creator.declare(any(ExchangeSpecification.class))) + .thenReturn(Mono.just(mock(AMQP.Exchange.DeclareOk.class))); // Act DomainEventBus domainBus = brokerProvider.getDomainBus(); // Assert @@ -106,9 +107,12 @@ void shouldCreateDomainEventBus() { void shouldCreateDirectAsyncGateway() { when(sender.getTopologyCreator()).thenReturn(creator); when(listener.getTopologyCreator()).thenReturn(creator); - when(creator.declare(any(ExchangeSpecification.class))).thenReturn(Mono.just(mock(AMQP.Exchange.DeclareOk.class))); - when(creator.bind(any(BindingSpecification.class))).thenReturn(Mono.just(mock(AMQP.Queue.BindOk.class))); - when(creator.declare(any(QueueSpecification.class))).thenReturn(Mono.just(mock(AMQP.Queue.DeclareOk.class))); + when(creator.declare(any(ExchangeSpecification.class))) + .thenReturn(Mono.just(mock(AMQP.Exchange.DeclareOk.class))); + when(creator.bind(any(BindingSpecification.class))) + .thenReturn(Mono.just(mock(AMQP.Queue.BindOk.class))); + when(creator.declare(any(QueueSpecification.class))) + .thenReturn(Mono.just(mock(AMQP.Queue.DeclareOk.class))); when(listener.getReceiver()).thenReturn(receiver); when(receiver.consumeAutoAck(any(String.class))).thenReturn(Flux.never()); // Act @@ -120,7 +124,8 @@ void shouldCreateDirectAsyncGateway() { @Test void shouldListenDomainEvents() { when(listener.getTopologyCreator()).thenReturn(creator); - when(creator.declare(any(ExchangeSpecification.class))).thenReturn(Mono.just(mock(AMQP.Exchange.DeclareOk.class))); + when(creator.declare(any(ExchangeSpecification.class))) + .thenReturn(Mono.just(mock(AMQP.Exchange.DeclareOk.class))); when(creator.declareQueue(any(String.class), any())).thenReturn(Mono.just(mock(AMQP.Queue.DeclareOk.class))); when(listener.getReceiver()).thenReturn(receiver); when(listener.getMaxConcurrency()).thenReturn(1); @@ -135,8 +140,10 @@ void shouldListenDomainEvents() { @SuppressWarnings({"rawtypes", "unchecked"}) void shouldListenNotificationEvents() { when(listener.getTopologyCreator()).thenReturn(creator); - when(creator.declare(any(ExchangeSpecification.class))).thenReturn(Mono.just(mock(AMQP.Exchange.DeclareOk.class))); - when(creator.declare(any(QueueSpecification.class))).thenReturn(Mono.just(mock(AMQP.Queue.DeclareOk.class))); + when(creator.declare(any(ExchangeSpecification.class))) + .thenReturn(Mono.just(mock(AMQP.Exchange.DeclareOk.class))); + when(creator.declare(any(QueueSpecification.class))) + .thenReturn(Mono.just(mock(AMQP.Queue.DeclareOk.class))); when(listener.getReceiver()).thenReturn(receiver); when(listener.getMaxConcurrency()).thenReturn(1); when(receiver.consumeManualAck(any(String.class), any())).thenReturn(Flux.never()); @@ -152,9 +159,12 @@ void shouldListenNotificationEvents() { @Test void shouldListenCommands() { when(listener.getTopologyCreator()).thenReturn(creator); - when(creator.declare(any(ExchangeSpecification.class))).thenReturn(Mono.just(mock(AMQP.Exchange.DeclareOk.class))); - when(creator.declareQueue(any(String.class), any())).thenReturn(Mono.just(mock(AMQP.Queue.DeclareOk.class))); - when(creator.bind(any(BindingSpecification.class))).thenReturn(Mono.just(mock(AMQP.Queue.BindOk.class))); + when(creator.declare(any(ExchangeSpecification.class))) + .thenReturn(Mono.just(mock(AMQP.Exchange.DeclareOk.class))); + when(creator.declareQueue(any(String.class), any())) + .thenReturn(Mono.just(mock(AMQP.Queue.DeclareOk.class))); + when(creator.bind(any(BindingSpecification.class))) + .thenReturn(Mono.just(mock(AMQP.Queue.BindOk.class))); when(listener.getReceiver()).thenReturn(receiver); when(listener.getMaxConcurrency()).thenReturn(1); when(receiver.consumeManualAck(any(String.class), any())).thenReturn(Flux.never()); @@ -167,9 +177,12 @@ void shouldListenCommands() { @Test void shouldListenQueries() { when(listener.getTopologyCreator()).thenReturn(creator); - when(creator.declare(any(ExchangeSpecification.class))).thenReturn(Mono.just(mock(AMQP.Exchange.DeclareOk.class))); - when(creator.declareQueue(any(String.class), any())).thenReturn(Mono.just(mock(AMQP.Queue.DeclareOk.class))); - when(creator.bind(any(BindingSpecification.class))).thenReturn(Mono.just(mock(AMQP.Queue.BindOk.class))); + when(creator.declare(any(ExchangeSpecification.class))) + .thenReturn(Mono.just(mock(AMQP.Exchange.DeclareOk.class))); + when(creator.declareQueue(any(String.class), any())) + .thenReturn(Mono.just(mock(AMQP.Queue.DeclareOk.class))); + when(creator.bind(any(BindingSpecification.class))) + .thenReturn(Mono.just(mock(AMQP.Queue.BindOk.class))); when(listener.getReceiver()).thenReturn(receiver); when(listener.getMaxConcurrency()).thenReturn(1); when(receiver.consumeManualAck(any(String.class), any())).thenReturn(Flux.never());