refs #216: Adds a Kotlin DSL for managing the core library. (#225)

This allows you to more easily create a MessageListenerContainer using
a simpler Kotlin DSL format. An example is something like:

```
val container = coreMessageListener("identifier", sqsAsyncClient, queueUrl) {
    retriever = prefetchingMessageRetriever {
        desiredPrefetchedMessages = 10
        maxPrefetchedMessages = 20
    }
    processor = coreProcessor {
        argumentResolverService = coreArgumentResolverService(objectMapper)
        bean = MessageListener()
        method = MessageListener::class.java.getMethod("listen", String::class.java)
    }
    broker = concurrentBroker {
        concurrencyLevel = { 10 }
        concurrencyPollingRate = { Duration.ofSeconds(30) }
    }
    resolver = batchingResolver {
        bufferingSizeLimit = { 5 }
        bufferingTime = { Duration.ofSeconds(2) }
    }
}
```

Author: JaidenAshmore

.markdownlinkcheck.json

@@ -5,6 +5,9 @@
     },
     {
       "pattern": "mailto:*"
+    },
+    {
+      "pattern": "https://coveralls.io.*"
     }
   ]
 }

README.md

@@ -305,6 +305,38 @@ to the maximum specified.
 10 above the desiredMinPrefetchedMessages will not provide much value as once it has prefetched more than the desired prefetched messages it will
 not prefetch anymore.*
 
+### Using the Core Library with a Kotlin DSL
+
+If you are not using Spring and want a way to more easily configure
+a [MessageListenerContainer](api/src/main/java/com/jashmore/sqs/container/MessageListenerContainer.java), you can use the
+[Core Kotlin DSL](extensions/core-kotlin-dsl) tool.
+
+```kotlin
+val container = coreMessageListener("identifier", sqsAsyncClient, queueUrl) {
+    retriever = prefetchingMessageRetriever {
+        desiredPrefetchedMessages = 10
+        maxPrefetchedMessages = 20
+    }
+    processor = coreProcessor {
+        argumentResolverService = coreArgumentResolverService(objectMapper)
+        bean = MessageListener()
+        method = MessageListener::class.java.getMethod("listen", String::class.java)
+    }
+    broker = concurrentBroker {
+        concurrencyLevel = { 10 }
+        concurrencyPollingRate = { Duration.ofSeconds(30) }
+    }
+    resolver = batchingResolver {
+        bufferingSizeLimit = { 5 }
+        bufferingTime = { Duration.ofSeconds(2) }
+    }
+}
+
+container.start()
+```
+
+For more details, see the [Core - How to use the Kotlin DSL](doc/how-to-guides/core/core-how-to-use-kotlin-dsl.md) guide.
+
 ### Adding Brave Tracing
 
 If you are using Brave Tracing in your application, for example using Spring Sleuth, you can hook into this system by including the
@@ -355,6 +387,8 @@ module. This allows you to test the performance and usage of each library for di
     extending the visibility of a message in the case of long processing so it does not get put back on the queue while processing
     1. [How to create a MessageProcessingDecorator](doc/how-to-guides/core/core-how-to-create-a-message-processing-decorator.md): guide for writing your own
     decorator to wrap a message listener's processing of a message
+    1. [How to use the Core Kotlin DSL](doc/how-to-guides/core/core-how-to-use-kotlin-dsl.md): guide for using the core library easier using a Kotlin
+    DSL for constructing message listeners
 1. Spring How To Guides
     1. [How to add a custom ArgumentResolver to a Spring application](doc/how-to-guides/spring/spring-how-to-add-custom-argument-resolver.md): useful for
     integrating custom argument resolution code to be included in a Spring Application. See [How to implement a custom ArgumentResolver](doc/how-to-guides/core/core-how-to-implement-a-custom-argument-resolver.md)

build.gradle.kts

@@ -1,6 +1,6 @@
-import com.jashmore.JacocoCoverallsPlugin
-import com.jashmore.ReleasePlugin
-import com.jashmore.release
+import com.jashmore.gradle.JacocoCoverallsPlugin
+import com.jashmore.gradle.ReleasePlugin
+import com.jashmore.gradle.release
 
 plugins {
     java
@@ -20,10 +20,13 @@ allprojects {
 }
 
 subprojects {
+    val isKotlinProject = project.name.contains("kotlin")
     apply(plugin = "java-library")
-    apply(plugin = "com.github.spotbugs")
-    apply(plugin = "checkstyle")
     apply(plugin = "jacoco")
+    if (!isKotlinProject) {
+        apply(plugin = "com.github.spotbugs")
+        apply(plugin = "checkstyle")
+    }
 
     dependencies {
         // AWS
@@ -49,8 +52,10 @@ subprojects {
         testImplementation("ch.qos.logback:logback-core")
         testImplementation("ch.qos.logback:logback-classic")
 
-        // SpotBugs
-        spotbugs("com.github.spotbugs:spotbugs:4.0.6")
+        if (!isKotlinProject) {
+            // SpotBugs
+            spotbugs("com.github.spotbugs:spotbugs:4.0.6")
+        }
 
         constraints {
             // Jackson
@@ -93,20 +98,22 @@ subprojects {
         options.compilerArgs.addAll(setOf("-Xlint:all", "-Werror", "-Xlint:-processing", "-Xlint:-serial"))
     }
 
-    tasks.withType<Checkstyle> {
-        // Needed because this is generated code and I am not good enough with gradle to properly exclude these source files
-        // from only the checkstyleTest task
-        exclude("**com/jashmore/sqs/extensions/registry/model/*")
-    }
+    if (!isKotlinProject) {
+        tasks.withType<Checkstyle> {
+            // Needed because this is generated code and I am not good enough with gradle to properly exclude these source files
+            // from only the checkstyleTest task
+            exclude("**com/jashmore/sqs/extensions/registry/model/*")
+        }
 
-    checkstyle {
-        configFile = file("${project.rootDir}/configuration/checkstyle/google_6_18_checkstyle.xml")
-        maxWarnings = 0
-        maxErrors = 0
-    }
+        checkstyle {
+            configFile = file("${project.rootDir}/configuration/checkstyle/google_6_18_checkstyle.xml")
+            maxWarnings = 0
+            maxErrors = 0
+        }
 
-    spotbugs {
-        excludeFilter.set(file("${project.rootDir}/configuration/spotbugs/bugsExcludeFilter.xml"))
+        spotbugs {
+            excludeFilter.set(file("${project.rootDir}/configuration/spotbugs/bugsExcludeFilter.xml"))
+        }
     }
 
     tasks.withType<Test> {

…in/com/jashmore/JacocoCoverallsPlugin.kt …jashmore/gradle/JacocoCoverallsPlugin.ktbuildSrc/src/main/kotlin/com/jashmore/JacocoCoverallsPlugin.kt renamed to buildSrc/src/main/kotlin/com/jashmore/gradle/JacocoCoverallsPlugin.kt buildSrc/src/main/kotlin/com/jashmore/JacocoCoverallsPlugin.kt renamed to buildSrc/src/main/kotlin/com/jashmore/gradle/JacocoCoverallsPlugin.kt

@@ -1,4 +1,4 @@
-package com.jashmore
+package com.jashmore.gradle
 
 import org.gradle.api.Plugin
 import org.gradle.api.Project

…ain/kotlin/com/jashmore/ReleasePlugin.kt …lin/com/jashmore/gradle/ReleasePlugin.ktbuildSrc/src/main/kotlin/com/jashmore/ReleasePlugin.kt renamed to buildSrc/src/main/kotlin/com/jashmore/gradle/ReleasePlugin.kt buildSrc/src/main/kotlin/com/jashmore/ReleasePlugin.kt renamed to buildSrc/src/main/kotlin/com/jashmore/gradle/ReleasePlugin.kt

@@ -1,6 +1,6 @@
-package com.jashmore
+package com.jashmore.gradle
 
-import com.jashmore.utils.isSnapshotVersion
+import com.jashmore.gradle.utils.isSnapshotVersion
 import io.codearte.gradle.nexus.NexusStagingExtension
 import io.codearte.gradle.nexus.NexusStagingPlugin
 import org.gradle.api.Plugin

…otlin/com/jashmore/utils/VersionUtils.kt …om/jashmore/gradle/utils/VersionUtils.ktbuildSrc/src/main/kotlin/com/jashmore/utils/VersionUtils.kt renamed to buildSrc/src/main/kotlin/com/jashmore/gradle/utils/VersionUtils.kt buildSrc/src/main/kotlin/com/jashmore/utils/VersionUtils.kt renamed to buildSrc/src/main/kotlin/com/jashmore/gradle/utils/VersionUtils.kt

@@ -1,3 +1,3 @@
-package com.jashmore.utils
+package com.jashmore.gradle.utils
 
 fun isSnapshotVersion(version: String) = version.endsWith("-SNAPSHOT")

buildSrc/src/main/resources/META-INF/gradle-plugins/com.jashmore.gradle.jacoco-coveralls.properties

@@ -0,0 +1 @@
+implementation-class=com.jashmore.gradle.JacocoCoverallsPlugin

buildSrc/src/main/resources/META-INF/gradle-plugins/com.jashmore.gradle.release.properties

@@ -0,0 +1 @@
+implementation-class=com.jashmore.gradle.ReleasePlugin

doc/how-to-guides/core/core-how-to-add-aws-xray-tracing.md

@@ -39,7 +39,7 @@ This will extract the tracing header from the SQS message and begin a Xray Segme
 ## Integration with AWS Xray Instrumentor
 
 If you want tracing information to be included when making client calls to AWS, you can add the
-[AWS Xray SDK V2 Instrumentor](https://github.com/aws/aws-xray-sdk-java/tree/master/aws-xray-recorder-sdk-aws-sdk-v2-instrumentor) dependency. 
+[AWS Xray SDK V2 Instrumentor](https://github.com/aws/aws-xray-sdk-java/tree/master/aws-xray-recorder-sdk-aws-sdk-v2-instrumentor) dependency.
 
 ```xml
     <dependency>
@@ -87,4 +87,3 @@ application, as all requests out to the SQS server will automatically be traced
 maintains its own threads and does not start Xray segments, all calls out to SQS will throw exceptions due to a missing segment.
 The [XrayWrappedSqsAsyncClient](../../../extensions/aws-xray-extension/core/src/main/java/com/jashmore/sqs/extensions/xray/client/XrayWrappedSqsAsyncClient.java)
 protects against these errors by making sure there is always a segment present when making a call with the client by creating one for you.
-

doc/how-to-guides/core/core-how-to-use-kotlin-dsl.md

@@ -0,0 +1,59 @@
+# Core - Kotlin DSL
+
+As the [core](../../../core) library can be quite verbose to configure
+a [MessageListenerContainer](../../../api/src/main/java/com/jashmore/sqs/container/MessageListenerContainer.java),
+the [Core Kotlin DSL](../../../extensions/core-kotlin-dsl) tool can be used to easily set up a message listener.
+
+## Steps
+
+1. Depend on the [Core Kotlin DSL](../../../extensions/core-kotlin-dsl) module:
+
+    ```kotlin
+    implementation("com.jashmore:core-kotlin-dsl:${version}")
+    ```
+
+   or
+
+    ```xml
+    <dependency>
+        <groupId>com.jashmore</groupId>
+        <artifactId>core-kotlin-dsl</artifactId>
+        <version>${version}</version>
+    </dependency>
+    ```
+
+1. Create the [MessageListenerContainer](../../../api/src/main/java/com/jashmore/sqs/container/MessageListenerContainer.java) using the Kotlin DSL
+
+    ```kotlin
+        val container = coreMessageListener("identifier", sqsAsyncClient, queueUrl) {
+            retriever = prefetchingMessageRetriever {
+                desiredPrefetchedMessages = 10
+                maxPrefetchedMessages = 20
+            }
+            processor = coreProcessor {
+                argumentResolverService = coreArgumentResolverService(objectMapper)
+                bean = MessageListener()
+                method = MessageListener::class.java.getMethod("listen", String::class.java)
+            }
+            broker = concurrentBroker {
+                concurrencyLevel = { 10 }
+                concurrencyPollingRate = { Duration.ofSeconds(30) }
+            }
+            resolver = batchingResolver {
+                bufferingSizeLimit = { 5 }
+                bufferingTime = { Duration.ofSeconds(2) }
+            }
+        }
+    ```
+
+1. Start the container as normal
+
+    ```kotlin
+        container.start()
+    ```
+
+Check out the [Core Kotlin DSL](../../../extensions/core-kotlin-dsl) for more details about the internals of this module and what you can use.
+
+## Example
+
+A full example of using the Kotlin DSL can be found in the [core-kotlin-example](../../../examples/core-kotlin-example/README.md).