Improved examples by improving output and demonstrating some use cases through tests. (apache#48)

Author: Steve973

dynamic-router-eip/README.adoc

@@ -110,6 +110,18 @@ If you want to run the Dynamic Router in "allMatch" receiver mode, run the examp
 
 The results should show up in less than ten seconds, and the program will immediately terminate.
 
+=== Run Tests
+
+You can run the tests using:
+
+    $mvn test
+
+There are some demos that run during the test phase.  Currently, there are three:
+
+ 1. AllRecipientsApplicationTest: the recipient mode is set to "allMatch" and 1,000,000 messages are sent through the router.
+ 2. FirstRecipientApplicationTest: the recipient mode is set to "firstMatch" and 1,000,000 messages are sent through the router.
+ 3. LessExpectedApplicationTest: the recipient mode is set to "firstMatch", and 10,000 messages are sent through the router.  The difference, here, is that the expected count is set to only 1,000 messages, so the results are calculated and displayed before all 10,000 messages are routed.
+
 === Help and contributions
 
 If you hit any problem using Camel or have some feedback, then please

dynamic-router-eip/pom.xml

@@ -76,7 +76,21 @@
             <artifactId>spring-boot-configuration-processor</artifactId>
             <optional>true</optional>
         </dependency>
-
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-launcher</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>

dynamic-router-eip/src/main/java/org/apache/camel/example/springboot/numbers/config/DynamicRouterComponentConfig.java

@@ -19,14 +19,19 @@
 import org.apache.camel.ConsumerTemplate;
 import org.apache.camel.ProducerTemplate;
 import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.component.dynamicrouter.DynamicRouterConfiguration;
+import org.apache.camel.component.dynamicrouter.DynamicRouterConstants;
 import org.apache.camel.example.springboot.numbers.participants.PredicateConstants;
 import org.apache.camel.example.springboot.numbers.participants.RoutingParticipant;
 import org.apache.camel.example.springboot.numbers.service.ResultsService;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
+import java.util.concurrent.CountDownLatch;
+
 import static org.apache.camel.component.dynamicrouter.DynamicRouterConstants.COMPONENT_SCHEME;
+import static org.apache.camel.component.dynamicrouter.DynamicRouterConstants.MODE_FIRST_MATCH;
 import static org.apache.camel.example.springboot.numbers.participants.PredicateConstants.PREDICATE_EIGHTS;
 import static org.apache.camel.example.springboot.numbers.participants.PredicateConstants.PREDICATE_EVEN;
 import static org.apache.camel.example.springboot.numbers.participants.PredicateConstants.PREDICATE_FIVES;
@@ -78,6 +83,29 @@ public void configure() {
         };
     }
 
+    /**
+     * Create a {@link CountDownLatch} so that we can wait on it for the total
+     * expected number of messages to be received.  Depending on the configured
+     * value of {@link ExampleConfig#getRecipientMode()}, this latch will be
+     * created with {@link ExampleConfig#getExpectedAllMatchMessageCount()} or
+     * {@link ExampleConfig#getExpectedFirstMatchMessageCount()}.
+     *
+     * @see DynamicRouterConstants#MODE_ALL_MATCH
+     * @see DynamicRouterConstants#MODE_FIRST_MATCH
+     * @see DynamicRouterConfiguration#getRecipientMode()
+     * @see ExampleConfig#getRecipientMode()
+     * @see ExampleConfig#getExpectedAllMatchMessageCount()
+     * @see ExampleConfig#getExpectedFirstMatchMessageCount()
+     *
+     * @return a countdown latch set to the number of expected messages
+     */
+    @Bean
+    CountDownLatch countDownLatch() {
+        return new CountDownLatch(MODE_FIRST_MATCH.equals(exampleConfig.getRecipientMode()) ?
+                exampleConfig.getExpectedFirstMatchMessageCount() :
+                exampleConfig.getExpectedAllMatchMessageCount());
+    }
+
     /**
      * Create a {@link RoutingParticipant} that handles messages where the body is comprised of a number that is
      * a multiple of 10.

dynamic-router-eip/src/main/java/org/apache/camel/example/springboot/numbers/config/ExampleConfig.java

@@ -18,6 +18,8 @@
 
 import org.springframework.boot.context.properties.ConfigurationProperties;
 
+import java.util.concurrent.CountDownLatch;
+
 /**
  * The config properties object from the application.yml file.
  */
@@ -50,6 +52,33 @@ public class ExampleConfig {
      */
     private String recipientMode;
 
+    /**
+     * The number of messages to send.
+     */
+    private int sendMessageCount;
+
+    /**
+     * If the recipient mode is "firstMatch", then this is the number of
+     * messages that are expected to be received.  This value is also used
+     * to create a {@link CountDownLatch} so that all messages can be
+     * received before printing out messaging statistics.
+     */
+    private int expectedFirstMatchMessageCount;
+
+    /**
+     * If the recipient mode is "allMatch", then this is the number of
+     * messages that are expected to be received.  There is probably not an
+     * easy way to calculate this number, so the number needs to be known
+     * for a given {@link #sendMessageCount} value.  This value is also used
+     * to create a {@link CountDownLatch} so that all messages can be
+     * received before printing out messaging statistics.
+     */
+    private int expectedAllMatchMessageCount;
+
+    /**
+     * The URI where messages will be sent to as the starting point for the
+     * route that feeds the dynamic router.
+     */
     public String getStartUri() {
         return startUri;
     }
@@ -58,6 +87,9 @@ public void setStartUri(String startUri) {
         this.startUri = startUri;
     }
 
+    /**
+     * The dynamic router channel.
+     */
     public String getRoutingChannel() {
         return routingChannel;
     }
@@ -66,6 +98,9 @@ public void setRoutingChannel(String routingChannel) {
         this.routingChannel = routingChannel;
     }
 
+    /**
+     * The dynamic router control channel URI
+     */
     public String getSubscribeUri() {
         return subscribeUri;
     }
@@ -74,6 +109,9 @@ public void setSubscribeUri(String subscribeUri) {
         this.subscribeUri = subscribeUri;
     }
 
+    /**
+     * The scheme that routing participants will use to listen for messages.
+     */
     public String getReceiverScheme() {
         return receiverScheme;
     }
@@ -82,11 +120,55 @@ public void setReceiverScheme(String receiverScheme) {
         this.receiverScheme = receiverScheme;
     }
 
+    /**
+     * The recipient mode -- first matching filter only, or all matching filters.
+     */
     public String getRecipientMode() {
         return this.recipientMode;
     }
 
     public void setRecipientMode(String recipientMode) {
         this.recipientMode = recipientMode;
     }
+
+    /**
+     * The number of messages to send.
+     */
+    public int getSendMessageCount() {
+        return sendMessageCount;
+    }
+
+    public void setSendMessageCount(int sendMessageCount) {
+        this.sendMessageCount = sendMessageCount;
+    }
+
+    /**
+     * If the recipient mode is "firstMatch", then this is the number of
+     * messages that are expected to be received.  This value is also used
+     * to create a {@link CountDownLatch} so that all messages can be
+     * received before printing out messaging statistics.
+     */
+    public int getExpectedFirstMatchMessageCount() {
+        return expectedFirstMatchMessageCount;
+    }
+
+    public void setExpectedFirstMatchMessageCount(int expectedFirstMatchMessageCount) {
+        this.expectedFirstMatchMessageCount = expectedFirstMatchMessageCount;
+    }
+
+    /**
+     * If the recipient mode is "allMatch", then this is the number of
+     * messages that are expected to be received.  There is probably not an
+     * easy way to calculate this number, so the number needs to be known
+     * for a given {@link #sendMessageCount} value.  This value is also used
+     * to create a {@link CountDownLatch} so that all messages can be
+     * received before printing out messaging statistics.
+     */
+    public int getExpectedAllMatchMessageCount() {
+        return expectedAllMatchMessageCount;
+    }
+
+    public void setExpectedAllMatchMessageCount(int expectedAllMatchMessageCount) {
+        this.expectedAllMatchMessageCount = expectedAllMatchMessageCount;
+    }
 }

dynamic-router-eip/src/main/java/org/apache/camel/example/springboot/numbers/service/NumbersService.java

@@ -23,15 +23,19 @@
 import org.apache.camel.util.StopWatch;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.boot.SpringApplication;
 import org.springframework.boot.context.event.ApplicationReadyEvent;
-import org.springframework.context.ApplicationContext;
 import org.springframework.context.event.EventListener;
 import org.springframework.stereotype.Service;
 
+import java.text.NumberFormat;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executors;
 import java.util.stream.IntStream;
 
+import static java.util.concurrent.TimeUnit.*;
+
 /**
  * Create numbers and send them to the dynamic router so that they can be
  * processed and binned to demonstrate the usage of the dynamic router
@@ -42,6 +46,8 @@ public class NumbersService {
 
     private static final Logger LOG = LoggerFactory.getLogger(NumbersService.class);
 
+    private final NumberFormat numberFormat = NumberFormat.getIntegerInstance();
+
     /**
      * The URI to send the messages to.  This URI feeds the dynamic router in a
      * Camel route.
@@ -67,32 +73,37 @@ public class NumbersService {
     private final ResultsService resultsService;
 
     /**
-     * The Spring Boot {@link ApplicationContext} so that the app can be
-     * programmatically shut down when we are finished processing all
-     * messages and displaying results.
+     * The {@link CountDownLatch} to wait for the total expected number of
+     * messages to be received.
+     */
+    final CountDownLatch countDownLatch;
+
+    /**
+     * The number of messages to generate.
      */
-    private final ApplicationContext applicationContext;
+    final int numberOfMessages;
 
     /**
-     * Create this service with all of the things.
+     * Create this service with everything.
      *
-     * @param config the configuration object representing the config properties
-     * @param participants the dynamic router participants
-     * @param start the producer template to send messages to the start endpoint
-     * @param resultsService the service that compiles routing results
-     * @param applicationContext the Spring app context for exiting when processing is complete
+     * @param config             the configuration object representing the config properties
+     * @param participants       the dynamic router participants
+     * @param start              the producer template to send messages to the start endpoint
+     * @param resultsService     the service that compiles routing results
+     * @param countDownLatch     the latch to wait for all messages to be received
      */
     public NumbersService(
             final ExampleConfig config,
             final List<RoutingParticipant> participants,
             final ProducerTemplate start,
             final ResultsService resultsService,
-            final ApplicationContext applicationContext) {
+            final CountDownLatch countDownLatch) {
         this.startUri = config.getStartUri();
         this.participants = participants;
         this.start = start;
         this.resultsService = resultsService;
-        this.applicationContext = applicationContext;
+        this.countDownLatch = countDownLatch;
+        this.numberOfMessages = config.getSendMessageCount();
     }
 
     /**
@@ -101,21 +112,23 @@ public NumbersService(
      * display the results and exit the app.
      */
     @EventListener(ApplicationReadyEvent.class)
-    public void start() {
-        LOG.info("Subscribing participants");
+    public void start() throws InterruptedException {
+        LOG.info("Subscribing {} participants", participants.size());
         participants.forEach(RoutingParticipant::subscribe);
-        StopWatch watch = new StopWatch();
-        LOG.info("Sending messages to the dynamic router");
-        sendMessages();
+        final StopWatch watch = new StopWatch();
+        LOG.info("Sending {} messages to the dynamic router: {}", numberFormat.format(numberOfMessages), getStartUri());
+        CompletableFuture.runAsync(this::sendMessages, Executors.newSingleThreadExecutor());
+        if (!countDownLatch.await(1, MINUTES)) {
+            LOG.warn("Statistics may be inaccurate, since the operation timed out");
+        }
         LOG.info(resultsService.getStatistics(watch));
-        SpringApplication.exit(applicationContext);
     }
 
     /**
      * Sends the messages to the starting endpoint of the route.
      */
     public void sendMessages() {
-        IntStream.rangeClosed(1, 1000000).forEach(start::sendBody);
+        IntStream.rangeClosed(1, numberOfMessages).forEach(start::sendBody);
     }
 
     /**