build(sonar): Fix some sonar issues

juancgalvis · juancgalvis · commit 3b4e97bd2630 · 2024-10-08T17:13:57.000-05:00
diff --git a/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/KafkaDirectAsyncGateway.java b/async/async-kafka/src/main/java/org/reactivecommons/async/kafka/KafkaDirectAsyncGateway.java
@@ -8,68 +8,71 @@
 import reactor.core.publisher.Mono;
 
 public class KafkaDirectAsyncGateway implements DirectAsyncGateway {
+
+    public static final String NOT_IMPLEMENTED_YET = "Not implemented yet";
+
     @Override
     public <T> Mono<Void> sendCommand(Command<T> command, String targetName) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 
     @Override
     public <T> Mono<Void> sendCommand(Command<T> command, String targetName, long delayMillis) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 
     @Override
     public <T> Mono<Void> sendCommand(Command<T> command, String targetName, String domain) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 
     @Override
     public <T> Mono<Void> sendCommand(Command<T> command, String targetName, long delayMillis, String domain) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 
     @Override
     public Mono<Void> sendCommand(CloudEvent command, String targetName) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 
     @Override
     public Mono<Void> sendCommand(CloudEvent command, String targetName, long delayMillis) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 
     @Override
     public Mono<Void> sendCommand(CloudEvent command, String targetName, String domain) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 
     @Override
     public Mono<Void> sendCommand(CloudEvent command, String targetName, long delayMillis, String domain) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 
     @Override
     public <T, R> Mono<R> requestReply(AsyncQuery<T> query, String targetName, Class<R> type) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 
     @Override
     public <T, R> Mono<R> requestReply(AsyncQuery<T> query, String targetName, Class<R> type, String domain) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 
     @Override
     public <R extends CloudEvent> Mono<R> requestReply(CloudEvent query, String targetName, Class<R> type) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 
     @Override
     public <R extends CloudEvent> Mono<R> requestReply(CloudEvent query, String targetName, Class<R> type, String domain) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 
     @Override
     public <T> Mono<Void> reply(T response, From from) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 }
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
@@ -9,6 +9,7 @@
 
 @AllArgsConstructor
 public class KafkaDomainEventBus implements DomainEventBus {
+    public static final String NOT_IMPLEMENTED_YET = "Not implemented yet";
     private final ReactiveMessageSender sender;
 
     @Override
@@ -18,7 +19,7 @@ public <T> Publisher<Void> emit(DomainEvent<T> event) {
 
     @Override
     public <T> Publisher<Void> emit(String domain, DomainEvent<T> event) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 
     @Override
@@ -28,6 +29,6 @@ public Publisher<Void> emit(CloudEvent event) {
 
     @Override
     public Publisher<Void> emit(String domain, CloudEvent event) {
-        throw new UnsupportedOperationException("Not implemented yet");
+        throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);
     }
 }
diff --git a/main.gradle b/main.gradle
@@ -11,7 +11,7 @@ allprojects {
         maven { url 'https://repo.spring.io/milestone' }
     }
 
-    if (toPublish.split(',').contains(project.name) || project.name == 'ReactiveArchitectureCommons') {
+    if (toPublish.split(',').contains(project.name) || project.name == rootProject.name) {
 
         sonar {
             properties {
diff --git a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/impl/config/annotations/EnableDirectAsyncGateway.java b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/impl/config/annotations/EnableDirectAsyncGateway.java
@@ -1,6 +1,5 @@
 package org.reactivecommons.async.impl.config.annotations;
 
-import org.reactivecommons.async.starter.config.ReactiveCommonsConfig;
 import org.reactivecommons.async.starter.senders.DirectAsyncGatewayConfig;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
diff --git a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/ConnectionManager.java b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/ConnectionManager.java
@@ -19,15 +19,6 @@ public ConnectionManager addDomain(String domain, BrokerProvider domainConn) {
         return this;
     }
 
-    private BrokerProvider getChecked(String domain) {
-        BrokerProvider domainProvider = connections.get(domain);
-        if (domainProvider == null) {
-            throw new RuntimeException("You are trying to use the domain " + domain
-                    + " but this connection is not defined");
-        }
-        return domainProvider;
-    }
-
     public Map<String, BrokerProvider> getProviders() {
         return connections;
     }
diff --git a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/DomainHandlers.java b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/config/DomainHandlers.java
@@ -1,6 +1,7 @@
 package org.reactivecommons.async.starter.config;
 
 import org.reactivecommons.async.commons.HandlerResolver;
+import org.reactivecommons.async.starter.exceptions.InvalidConfigurationException;
 
 import java.util.Map;
 import java.util.TreeMap;
@@ -15,7 +16,7 @@ public void add(String domain, HandlerResolver resolver) {
     public HandlerResolver get(String domain) {
         HandlerResolver handlerResolver = handlers.get(domain);
         if (handlerResolver == null) {
-            throw new RuntimeException("You are trying to use the domain " + domain
+            throw new InvalidConfigurationException("You are trying to use the domain " + domain
                     + " but this connection is not defined");
         }
         return handlerResolver;
diff --git a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/listeners/AbstractListenerConfig.java b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/listeners/AbstractListenerConfig.java
@@ -1,13 +1,13 @@
 package org.reactivecommons.async.starter.listeners;
 
 import org.reactivecommons.async.commons.HandlerResolver;
-import org.reactivecommons.async.starter.config.ConnectionManager;
 import org.reactivecommons.async.starter.broker.BrokerProvider;
+import org.reactivecommons.async.starter.config.ConnectionManager;
 import org.reactivecommons.async.starter.config.DomainHandlers;
 
 public abstract class AbstractListenerConfig {
 
-    public AbstractListenerConfig(ConnectionManager manager, DomainHandlers handlers) {
+    protected AbstractListenerConfig(ConnectionManager manager, DomainHandlers handlers) {
         manager.forDomain((domain, provider) -> listen(domain, provider, handlers.get(domain)));
     }
 
diff --git a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/props/GenericAsyncProps.java b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/props/GenericAsyncProps.java
@@ -15,13 +15,13 @@ public abstract class GenericAsyncProps<P> {
     private String appName;
     private String secret;
 
-    abstract public void setConnectionProperties(P properties);
+    public abstract void setConnectionProperties(P properties);
 
-    abstract public P getConnectionProperties();
+    public abstract P getConnectionProperties();
 
-    abstract public String getBrokerType();
+    public abstract String getBrokerType();
 
-    abstract public boolean isEnabled();
+    public abstract boolean isEnabled();
 
-    abstract public void setUseDiscardNotifierPerDomain(boolean enabled);
+    public abstract void setUseDiscardNotifierPerDomain(boolean enabled);
 }
diff --git a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/props/GenericAsyncPropsDomain.java b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/props/GenericAsyncPropsDomain.java
@@ -2,6 +2,7 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.SneakyThrows;
@@ -10,6 +11,7 @@
 import java.lang.reflect.Constructor;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;
 
 import static org.reactivecommons.async.api.HandlerRegistry.DEFAULT_DOMAIN;
 
@@ -61,7 +63,7 @@ public GenericAsyncPropsDomain(String defaultAppName,
     }
 
     protected void fillCustoms(T asyncProps) {
-
+        // To be overridden called after the default properties are set
     }
 
     public T getProps(String domain) {
@@ -153,4 +155,17 @@ public interface SecretFiller<P> {
         void fillWithSecret(String domain, GenericAsyncProps<P> props);
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        if (!super.equals(o)) return false;
+        GenericAsyncPropsDomain<?, ?> that = (GenericAsyncPropsDomain<?, ?>) o;
+        return Objects.equals(asyncPropsClass, that.asyncPropsClass) && Objects.equals(propsClass, that.propsClass);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(super.hashCode(), asyncPropsClass, propsClass);
+    }
 }
diff --git a/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/props/GenericAsyncPropsDomainProperties.java b/starters/async-commons-starter/src/main/java/org/reactivecommons/async/starter/props/GenericAsyncPropsDomainProperties.java
@@ -10,7 +10,7 @@
 @Setter
 public class GenericAsyncPropsDomainProperties<T extends GenericAsyncProps<P>, P> extends HashMap<String, T> {
 
-    public GenericAsyncPropsDomainProperties(Map<? extends String, ? extends T> m) {
+    public GenericAsyncPropsDomainProperties(Map<String, ? extends T> m) {
         super(m);
     }
 
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
@@ -52,20 +52,18 @@ public DirectAsyncGateway getDirectAsyncGateway(HandlerResolver resolver) {
 
     @Override
     public void listenDomainEvents(HandlerResolver resolver) {
-        if (!props.getDomain().isIgnoreThisListener()) {
-            if (!resolver.getEventListeners().isEmpty()) {
-                ApplicationEventListener eventListener = new ApplicationEventListener(receiver,
-                        resolver,
-                        converter,
-                        props.getWithDLQRetry(),
-                        props.getCreateTopology(),
-                        props.getMaxRetries(),
-                        props.getRetryDelay(),
-                        discardNotifier,
-                        errorReporter,
-                        props.getAppName());
-                eventListener.startListener(topologyCreator);
-            }
+        if (!props.getDomain().isIgnoreThisListener() && !resolver.getEventListeners().isEmpty()) {
+            ApplicationEventListener eventListener = new ApplicationEventListener(receiver,
+                    resolver,
+                    converter,
+                    props.getWithDLQRetry(),
+                    props.getCreateTopology(),
+                    props.getMaxRetries(),
+                    props.getRetryDelay(),
+                    discardNotifier,
+                    errorReporter,
+                    props.getAppName());
+            eventListener.startListener(topologyCreator);
         }
     }
 
@@ -88,17 +86,17 @@ public void listenNotificationEvents(HandlerResolver resolver) {
 
     @Override
     public void listenCommands(HandlerResolver resolver) {
-
+        // Implemented in the future
     }
 
     @Override
     public void listenQueries(HandlerResolver resolver) {
-
+        // May be implemented in the future
     }
 
     @Override
     public void listenReplies(HandlerResolver resolver) {
-
+        // May be implemented in the future
     }
 
     @Override
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
@@ -38,9 +38,9 @@ public static ReactiveMessageSender createMessageSender(AsyncKafkaProps config,
                                                             TopologyCreator topologyCreator,
                                                             SslBundles sslBundles) {
         KafkaProperties props = config.getConnectionProperties();
-        props.setClientId(config.getAppName()); // CLIENT_ID_CONFIG
-        props.getProducer().setKeySerializer(StringSerializer.class); // KEY_SERIALIZER_CLASS_CONFIG;
-        props.getProducer().setValueSerializer(ByteArraySerializer.class); // VALUE_SERIALIZER_CLASS_CONFIG
+        props.setClientId(config.getAppName());
+        props.getProducer().setKeySerializer(StringSerializer.class);
+        props.getProducer().setValueSerializer(ByteArraySerializer.class);
         SenderOptions<String, byte[]> senderOptions = SenderOptions.create(props.buildProducerProperties(sslBundles));
         KafkaSender<String, byte[]> kafkaSender = KafkaSender.create(senderOptions);
         return new ReactiveMessageSender(kafkaSender, converter, topologyCreator);
@@ -50,8 +50,8 @@ public static ReactiveMessageSender createMessageSender(AsyncKafkaProps config,
 
     public static ReactiveMessageListener createMessageListener(AsyncKafkaProps config, SslBundles sslBundles) {
         KafkaProperties props = config.getConnectionProperties();
-        props.getConsumer().setKeyDeserializer(StringDeserializer.class); // KEY_DESERIALIZER_CLASS_CONFIG
-        props.getConsumer().setValueDeserializer(ByteArrayDeserializer.class); // VALUE_DESERIALIZER_CLASS_CONFIG
+        props.getConsumer().setKeyDeserializer(StringDeserializer.class);
+        props.getConsumer().setValueDeserializer(ByteArrayDeserializer.class);
         ReceiverOptions<String, byte[]> receiverOptions = ReceiverOptions.create(props.buildConsumerProperties(sslBundles));
         return new ReactiveMessageListener(receiverOptions);
     }
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
@@ -22,13 +22,17 @@ public class DirectAsyncGatewayConfig {
     private String appName;
 
 
-    public RabbitDirectAsyncGateway rabbitDirectAsyncGateway(BrokerConfig config, ReactiveReplyRouter router, ReactiveMessageSender rSender, MessageConverter converter,
-                                                             MeterRegistry meterRegistry) throws Exception {
-        return new RabbitDirectAsyncGateway(config, router, rSender, directMessagesExchangeName, converter, meterRegistry);
+    public RabbitDirectAsyncGateway rabbitDirectAsyncGateway(BrokerConfig config, ReactiveReplyRouter router,
+                                                             ReactiveMessageSender rSender, MessageConverter converter,
+                                                             MeterRegistry meterRegistry) {
+        return new RabbitDirectAsyncGateway(config, router, rSender, directMessagesExchangeName, converter,
+                meterRegistry);
     }
 
-    public ApplicationReplyListener msgListener(ReactiveReplyRouter router, BrokerConfig config, ReactiveMessageListener listener, boolean createTopology) {
-        final ApplicationReplyListener replyListener = new ApplicationReplyListener(router, listener, generateName(), globalReplyExchangeName, createTopology);
+    public ApplicationReplyListener msgListener(ReactiveReplyRouter router, BrokerConfig config,
+                                                ReactiveMessageListener listener, boolean createTopology) {
+        final ApplicationReplyListener replyListener = new ApplicationReplyListener(router, listener, generateName(),
+                globalReplyExchangeName, createTopology);
         replyListener.startListening(config.getRoutingKey());
         return replyListener;
     }
@@ -50,7 +54,7 @@ public String generateName() {
                 .putLong(uuid.getLeastSignificantBits());
         // Convert to base64 and remove trailing =
         return this.appName + encodeToUrlSafeString(bb.array())
-                .replaceAll("=", "");
+                .replace("=", "");
     }
 
     public static String encodeToUrlSafeString(byte[] src) {
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
@@ -3,17 +3,21 @@
 import com.rabbitmq.client.Connection;
 import com.rabbitmq.client.ConnectionFactory;
 import lombok.extern.java.Log;
-import org.reactivecommons.async.rabbit.communications.ReactiveMessageSender;
-import org.reactivecommons.async.rabbit.communications.TopologyCreator;
 import org.reactivecommons.async.commons.converters.MessageConverter;
 import org.reactivecommons.async.commons.converters.json.ObjectMapperSupplier;
+import org.reactivecommons.async.rabbit.communications.ReactiveMessageSender;
+import org.reactivecommons.async.rabbit.communications.TopologyCreator;
 import org.reactivecommons.async.rabbit.config.ConnectionFactoryProvider;
 import org.reactivecommons.async.rabbit.converters.json.RabbitJacksonMessageConverter;
 import reactor.core.publisher.Mono;
-import reactor.rabbitmq.*;
+import reactor.rabbitmq.ChannelPool;
+import reactor.rabbitmq.ChannelPoolFactory;
+import reactor.rabbitmq.ChannelPoolOptions;
+import reactor.rabbitmq.RabbitFlux;
+import reactor.rabbitmq.Sender;
+import reactor.rabbitmq.SenderOptions;
 import reactor.util.retry.Retry;
 
-import java.io.File;
 import java.time.Duration;
 import java.util.logging.Level;
 
@@ -40,12 +44,6 @@ public ReactiveMessageSender messageSender(ConnectionFactoryProvider provider, M
         return new ReactiveMessageSender(sender, appName, converter, new TopologyCreator(sender));
     }
 
-    /*public ReactiveMessageListener messageListener(ConnectionFactoryProvider provider) {
-        final Mono<Connection> connection = createSenderConnectionMono(provider.getConnectionFactory(), "listener");
-        Receiver receiver = RabbitFlux.createReceiver(new ReceiverOptions().connectionMono(connection));
-        return new ReactiveMessageListener(receiver, new TopologyCreator(connection));
-    }*/
-
     public ConnectionFactoryProvider connectionFactory(RabbitProperties properties) {
         final ConnectionFactory factory = new ConnectionFactory();
         factory.setHost(properties.getHost());
diff --git a/starters/async-rabbit-standalone/src/main/java/org/reactivecommons/async/rabbit/standalone/config/RabbitProperties.java b/starters/async-rabbit-standalone/src/main/java/org/reactivecommons/async/rabbit/standalone/config/RabbitProperties.java
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
diff --git a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/health/RabbitMQHealthException.java b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/health/RabbitMQHealthException.java
diff --git a/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/health/RabbitReactiveHealthIndicator.java b/starters/async-rabbit-starter/src/main/java/org/reactivecommons/async/rabbit/health/RabbitReactiveHealthIndicator.java

Original file line number	Diff line number	Diff line change
`@@ -8,68 +8,71 @@`
`8`	`8`	`import reactor.core.publisher.Mono;`
`9`	`9`
`10`	`10`	`public class KafkaDirectAsyncGateway implements DirectAsyncGateway {`
	`11`	`+`
	`12`	`+ public static final String NOT_IMPLEMENTED_YET = "Not implemented yet";`
	`13`	`+`
`11`	`14`	`@Override`
`12`	`15`	`public <T> Mono<Void> sendCommand(Command<T> command, String targetName) {`
`13`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`16`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`14`	`17`	`}`
`15`	`18`
`16`	`19`	`@Override`
`17`	`20`	`public <T> Mono<Void> sendCommand(Command<T> command, String targetName, long delayMillis) {`
`18`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`21`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`19`	`22`	`}`
`20`	`23`
`21`	`24`	`@Override`
`22`	`25`	`public <T> Mono<Void> sendCommand(Command<T> command, String targetName, String domain) {`
`23`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`26`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`24`	`27`	`}`
`25`	`28`
`26`	`29`	`@Override`
`27`	`30`	`public <T> Mono<Void> sendCommand(Command<T> command, String targetName, long delayMillis, String domain) {`
`28`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`31`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`29`	`32`	`}`
`30`	`33`
`31`	`34`	`@Override`
`32`	`35`	`public Mono<Void> sendCommand(CloudEvent command, String targetName) {`
`33`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`36`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`34`	`37`	`}`
`35`	`38`
`36`	`39`	`@Override`
`37`	`40`	`public Mono<Void> sendCommand(CloudEvent command, String targetName, long delayMillis) {`
`38`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`41`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`39`	`42`	`}`
`40`	`43`
`41`	`44`	`@Override`
`42`	`45`	`public Mono<Void> sendCommand(CloudEvent command, String targetName, String domain) {`
`43`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`46`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`44`	`47`	`}`
`45`	`48`
`46`	`49`	`@Override`
`47`	`50`	`public Mono<Void> sendCommand(CloudEvent command, String targetName, long delayMillis, String domain) {`
`48`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`51`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`49`	`52`	`}`
`50`	`53`
`51`	`54`	`@Override`
`52`	`55`	`public <T, R> Mono<R> requestReply(AsyncQuery<T> query, String targetName, Class<R> type) {`
`53`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`56`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`54`	`57`	`}`
`55`	`58`
`56`	`59`	`@Override`
`57`	`60`	`public <T, R> Mono<R> requestReply(AsyncQuery<T> query, String targetName, Class<R> type, String domain) {`
`58`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`61`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`59`	`62`	`}`
`60`	`63`
`61`	`64`	`@Override`
`62`	`65`	`public <R extends CloudEvent> Mono<R> requestReply(CloudEvent query, String targetName, Class<R> type) {`
`63`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`66`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`64`	`67`	`}`
`65`	`68`
`66`	`69`	`@Override`
`67`	`70`	`public <R extends CloudEvent> Mono<R> requestReply(CloudEvent query, String targetName, Class<R> type, String domain) {`
`68`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`71`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`69`	`72`	`}`
`70`	`73`
`71`	`74`	`@Override`
`72`	`75`	`public <T> Mono<Void> reply(T response, From from) {`
`73`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`76`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`74`	`77`	`}`
`75`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`
`10`	`10`	`@AllArgsConstructor`
`11`	`11`	`public class KafkaDomainEventBus implements DomainEventBus {`
	`12`	`+ public static final String NOT_IMPLEMENTED_YET = "Not implemented yet";`
`12`	`13`	`private final ReactiveMessageSender sender;`
`13`	`14`
`14`	`15`	`@Override`
`@@ -18,7 +19,7 @@ public <T> Publisher<Void> emit(DomainEvent<T> event) {`
`18`	`19`
`19`	`20`	`@Override`
`20`	`21`	`public <T> Publisher<Void> emit(String domain, DomainEvent<T> event) {`
`21`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`22`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`22`	`23`	`}`
`23`	`24`
`24`	`25`	`@Override`
`@@ -28,6 +29,6 @@ public Publisher<Void> emit(CloudEvent event) {`
`28`	`29`
`29`	`30`	`@Override`
`30`	`31`	`public Publisher<Void> emit(String domain, CloudEvent event) {`
`31`		`- throw new UnsupportedOperationException("Not implemented yet");`
	`32`	`+ throw new UnsupportedOperationException(NOT_IMPLEMENTED_YET);`
`32`	`33`	`}`
`33`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ allprojects {`
`11`	`11`	`maven { url 'https://repo.spring.io/milestone' }`
`12`	`12`	`}`
`13`	`13`
`14`		`- if (toPublish.split(',').contains(project.name) \|\| project.name == 'ReactiveArchitectureCommons') {`
	`14`	`+ if (toPublish.split(',').contains(project.name) \|\| project.name == rootProject.name) {`
`15`	`15`
`16`	`16`	`sonar {`
`17`	`17`	`properties {`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`	`@Setter`
`11`	`11`	`public class GenericAsyncPropsDomainProperties<T extends GenericAsyncProps<P>, P> extends HashMap<String, T> {`
`12`	`12`
`13`		`- public GenericAsyncPropsDomainProperties(Map<? extends String, ? extends T> m) {`
	`13`	`+ public GenericAsyncPropsDomainProperties(Map<String, ? extends T> m) {`
`14`	`14`	`super(m);`
`15`	`15`	`}`
`16`	`16`