Added test jar and classes for aeron server/client

build.gradle.kts

@@ -30,6 +30,8 @@ plugins {
     id("com.dorkbox.VersionUpdate") version "2.5"
     id("com.dorkbox.GradlePublish") version "1.12"
 
+    id("com.github.johnrengelman.shadow") version "7.1.2"
+
     kotlin("jvm") version "1.6.10"
 }
 
@@ -139,6 +141,26 @@ tasks.jar.get().apply {
     }
 }
 
+
+val shadowJar: com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar by tasks
+shadowJar.apply {
+    manifest.inheritFrom(tasks.jar.get().manifest)
+
+    manifest.attributes.apply {
+        put("Main-Class", "dorkboxTest.network.AeronClientServer")
+    }
+
+    mergeServiceFiles()
+
+    duplicatesStrategy = DuplicatesStrategy.INCLUDE
+
+    from(sourceSets.test.get().output)
+    configurations = listOf(project.configurations.testRuntimeClasspath.get())
+
+    archiveBaseName.set(project.name + "-all")
+}
+
+
 dependencies {
     api("org.jetbrains.kotlinx:atomicfu:0.17.3")
     api("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.2")

test/dorkboxTest/network/AeronClientServer.kt

@@ -32,15 +32,13 @@ import dorkbox.storage.Storage
 import org.slf4j.LoggerFactory
 import sun.misc.Unsafe
 import java.lang.reflect.Field
-import java.text.SimpleDateFormat
-import java.util.*
 
 /**
  *
  */
 @Suppress("UNUSED_ANONYMOUS_PARAMETER")
-object AeronClientServer {
+class AeronClientServer {
-
+    companion object {
         init {
             try {
                 val theUnsafe = Unsafe::class.java.getDeclaredField("theUnsafe")
@@ -92,12 +90,6 @@ object AeronClientServer {
             rootLogger.addAppender(consoleAppender)
         }
 
-    fun convertLongToTime(time: Long): String {
-        val date = Date(time)
-        val format = SimpleDateFormat("yyyy.MM.dd HH:mm:ss")
-        return format.format(date)
-    }
-
         /**
          * Command-line entry point.
          *
@@ -108,7 +100,95 @@ object AeronClientServer {
         @Throws(Exception::class)
         @JvmStatic
         fun main(args: Array<String>) {
-        run {
+            val acs = AeronClientServer()
+
+            if (args.contains("client")) {
+                acs.client("172.31.79.129")
+            } else if (args.contains("server")) {
+                val server = acs.server()
+                server.waitForClose()
+            } else {
+                acs.server()
+                acs.client("localhost")
+            }
+        }
+    }
+
+
+    fun client(remoteAddress: String) {
+        val configuration = ClientConfiguration()
+        configuration.settingsStore = Storage.Memory() // don't want to persist anything on disk!
+        configuration.port = 2000
+
+        configuration.enableIpc = false
+//            configuration.enableIPv4 = false
+        configuration.enableIPv6 = false
+
+//            configuration.uniqueAeronDirectory = true
+
+        val client = Client<Connection>(configuration)
+
+        client.filter(IpSubnetFilterRule(IPv4.LOCALHOST, 32))
+
+        client.filter {
+            println("should this connection be allowed?")
+            true
+        }
+
+        client.onInit {
+            logger.error("initialized")
+        }
+
+        client.onConnect {
+            logger.error("connected")
+            send("HI THERE!")
+        }
+
+        client.onDisconnect {
+            logger.error("disconnect")
+        }
+
+        client.onError { throwable ->
+            logger.error("has error")
+            throwable.printStackTrace()
+        }
+
+        client.onMessage<String> { message ->
+            logger.error("HAS MESSAGE! $message")
+        }
+
+        client.connect(remoteAddress) // UDP connection via loopback
+
+
+        // different ones needed
+        // send - reliable
+        // send - unreliable
+        // send - priority (0-255 -- 255 is MAX priority) when sending, max is always sent immediately, then lower priority is sent if there is no backpressure from the MediaDriver.
+        // send - IPC/local
+//        runBlocking {
+//            while (!client.isShutdown()) {
+//                client.send("ECHO " + java.lang.Long.toUnsignedString(client.crypto.secureRandom.nextLong(), 16))
+//            }
+//        }
+
+
+        // connection needs to know
+        // is UDP or IPC
+        // host address
+
+        // RMI
+        // client.get(5) -> gets from the server connection, if exists, then global.
+        //                  on server, a connection local RMI object "uses" an id for global, so there will never be a conflict
+        //                  using some tricks, we can make it so that it DOESN'T matter the order in which objects are created,
+        //                  and can specify, if we want, the object created.
+        //                 Once created though, as NEW ONE with the same ID cannot be created until the old one is removed!
+
+        Thread.sleep(2000L)
+        client.close()
+    }
+
+
+    fun server(): Server<Connection> {
         val configuration = ServerConfiguration()
         configuration.settingsStore = Storage.Memory() // don't want to persist anything on disk!
         configuration.listenIpAddress = "*"
@@ -117,7 +197,7 @@ object AeronClientServer {
 
         configuration.enableIpc = false
 //            configuration.enableIPv4 = false
-//            configuration.enableIPv6 = false
+        configuration.enableIPv6 = false
 
         configuration.maxConnectionsPerIpAddress = 50
 
@@ -162,79 +242,8 @@ object AeronClientServer {
         }
 
         server.bind()
+
+        return server as Server<Connection>
     }
 
-        run {
-            val configuration = ClientConfiguration()
-            configuration.settingsStore = Storage.Memory() // don't want to persist anything on disk!
-            configuration.port = 2000
-
-            configuration.enableIpc = false
-//            configuration.enableIPv4 = false
-//            configuration.enableIPv6 = false
-
-//            configuration.uniqueAeronDirectory = true
-
-            val client = Client<Connection>(configuration)
-
-            client.filter(IpSubnetFilterRule(IPv4.LOCALHOST, 32))
-
-            client.filter {
-                println("should this connection be allowed?")
-                true
-            }
-
-            client.onInit {
-                logger.error("initialized")
-            }
-
-            client.onConnect {
-                logger.error("connected")
-                send("HI THERE!")
-            }
-
-            client.onDisconnect {
-                logger.error("disconnect")
-            }
-
-            client.onError { throwable ->
-                logger.error("has error")
-                throwable.printStackTrace()
-            }
-
-            client.onMessage<String> { message ->
-                logger.error("HAS MESSAGE! $message")
-            }
-
-            client.connect("localhost") // UDP connection via loopback
-
-
-            // different ones needed
-            // send - reliable
-            // send - unreliable
-            // send - priority (0-255 -- 255 is MAX priority) when sending, max is always sent immediately, then lower priority is sent if there is no backpressure from the MediaDriver.
-            // send - IPC/local
-//        runBlocking {
-//            while (!client.isShutdown()) {
-//                client.send("ECHO " + java.lang.Long.toUnsignedString(client.crypto.secureRandom.nextLong(), 16))
-//            }
-//        }
-
-
-            // connection needs to know
-            // is UDP or IPC
-            // host address
-
-            // RMI
-            // client.get(5) -> gets from the server connection, if exists, then global.
-            //                  on server, a connection local RMI object "uses" an id for global, so there will never be a conflict
-            //                  using some tricks, we can make it so that it DOESN'T matter the order in which objects are created,
-            //                  and can specify, if we want, the object created.
-            //                 Once created though, as NEW ONE with the same ID cannot be created until the old one is removed!
-
-            Thread.sleep(2000L)
-            client.close()
-        }
-
-    }
 }