impl: Add the roaming state to ActiveConnection

In some of the use cases, I needed the active
connection to keep living after the server thread
that spawned it went out of scope. This change
makes it possible by adding a new state called
'roaming' which allows the server (or any other
owner) to skip closing the instance.

Author: velitasali

pom.xml

@@ -5,7 +5,7 @@
 
     <groupId>org.monora.coolsocket</groupId>
     <artifactId>core</artifactId>
-    <version>2.0-rc16</version>
+    <version>2.0-rc17</version>
     <name>CoolSocket</name>
     <description>Bidirectional TCP socket layer and server</description>
     <url>https://github.com/libcoolsocket</url>
@@ -175,4 +175,4 @@
             <scope>compile</scope>
         </dependency>
     </dependencies>
-</project>
+</project>

src/main/java/org/monora/coolsocket/core/server/DefaultConnectionManager.java

@@ -76,9 +76,11 @@ public void handleClient(@NotNull CoolSocket coolSocket, final @NotNull ActiveCo
             } catch (Exception e) {
                 coolSocket.getLogger().log(Level.SEVERE, "An error occurred during handling of a client", e);
             } finally {
-                try {
-                    activeConnection.close();
-                } catch (IOException ignored) {
+                if (!activeConnection.isRoaming()) {
+                    try {
+                        activeConnection.close();
+                    } catch (IOException ignored) {
+                    }
                 }
 
                 synchronized (connectionList) {

src/main/java/org/monora/coolsocket/core/session/ActiveConnection.java

@@ -42,6 +42,8 @@ public class ActiveConnection implements Closeable
 
     private boolean closeRequested;
 
+    private boolean roaming = false;
+
     /**
      * Create an instance with a socket connection to a CoolSocket server.
      *
@@ -412,6 +414,33 @@ else if (protocolVersion == 0) {
         handleProtocolRequest(description, write);
     }
 
+    /**
+     * Check whether the roaming state is activated for this instance.
+     * <p>
+     * When in that state, connections won't be closed by their owners when they go out of scope.
+     * <p>
+     * For instance, a {@link CoolSocket} server will not {@link #close()} an instance after its child thread exits,
+     * allowing to you keep using the connection without having to block that child thread.
+     *
+     * @return True if the roaming is activated.
+     * @see #setRoaming(boolean)
+     */
+    public boolean isRoaming()
+    {
+        return roaming;
+    }
+
+    /**
+     * Change the roaming state of this instance.
+     *
+     * @param roaming True to enable the roaming state.
+     * @see #isRoaming()
+     */
+    public void setRoaming(boolean roaming)
+    {
+        this.roaming = roaming;
+    }
+
     /**
      * Read from the remote. This reads into the {@link Description#byteBuffer} and returns the length of the bytes
      * read.
@@ -1127,4 +1156,4 @@ public long totalLength()
             return totalLength;
         }
     }
-}
+}

src/test/java/org/monora/coolsocket/core/PlainTransactionTest.java

@@ -6,12 +6,10 @@
 import org.junit.Test;
 import org.monora.coolsocket.core.response.Response;
 import org.monora.coolsocket.core.session.ActiveConnection;
-import org.monora.coolsocket.core.variant.BlockingCoolSocket;
-import org.monora.coolsocket.core.variant.Connections;
-import org.monora.coolsocket.core.variant.DefaultCoolSocket;
-import org.monora.coolsocket.core.variant.StaticMessageCoolSocket;
+import org.monora.coolsocket.core.variant.*;
 
 import java.io.IOException;
+import java.net.SocketException;
 
 public class PlainTransactionTest
 {
@@ -169,4 +167,69 @@ public void onConnected(@NotNull ActiveConnection activeConnection)
             coolSocket.stop();
         }
     }
+
+    @Test(timeout = 10000)
+    public void roamingChildTest() throws IOException, InterruptedException
+    {
+        final String message = "Hello, World!";
+
+        RoamingChildCoolSocket coolSocket = new RoamingChildCoolSocket(true);
+        Thread thread = new Thread(() -> {
+            try {
+                ActiveConnection activeConnection = coolSocket.connectionsQueue.take();
+                CoolSocket.Session session = coolSocket.getSession();
+
+                Assert.assertNotNull("Session should not be null", session);
+
+                while (true) {
+                    if (session.getConnectionManager().getActiveConnectionList().size() < 1) break;
+                }
+
+                activeConnection.reply(message);
+            } catch (InterruptedException | IOException e) {
+                e.printStackTrace();
+            }
+        });
+
+        coolSocket.start();
+
+        try (ActiveConnection activeConnection = Connections.connect()) {
+            thread.start();
+            Assert.assertEquals("The messages should match", message, activeConnection.receive().getAsString());
+        } finally {
+            coolSocket.stop();
+        }
+    }
+
+    @Test(expected = SocketException.class, timeout = 10000)
+    public void nonRoamingChildClosesTest() throws IOException, InterruptedException
+    {
+        final String message = "Foo";
+
+        RoamingChildCoolSocket coolSocket = new RoamingChildCoolSocket(false);
+        Thread thread = new Thread(() -> {
+            try {
+                ActiveConnection activeConnection = coolSocket.connectionsQueue.take();
+                CoolSocket.Session session = coolSocket.getSession();
+
+                Assert.assertNotNull("Session should not be null", session);
+
+                while (true) {
+                    if (session.getConnectionManager().getActiveConnectionList().size() < 1) break;
+                }
+
+                activeConnection.reply(message);
+            } catch (InterruptedException | IOException ignored) {
+            }
+        });
+
+        coolSocket.start();
+
+        try (ActiveConnection activeConnection = Connections.connect()) {
+            thread.start();
+            Assert.assertEquals("The messages should match", message, activeConnection.receive().getAsString());
+        } finally {
+            coolSocket.stop();
+        }
+    }
 }

src/test/java/org/monora/coolsocket/core/variant/RoamingChildCoolSocket.java

@@ -0,0 +1,36 @@
+package org.monora.coolsocket.core.variant;
+
+import org.jetbrains.annotations.NotNull;
+import org.monora.coolsocket.core.CoolSocket;
+import org.monora.coolsocket.core.session.ActiveConnection;
+import org.monora.coolsocket.core.variant.factory.TestConfigFactory;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.SynchronousQueue;
+
+public class RoamingChildCoolSocket extends CoolSocket
+{
+    public final BlockingQueue<ActiveConnection> connectionsQueue = new SynchronousQueue<>();
+
+    public final boolean roamingEnabled;
+
+    public RoamingChildCoolSocket(boolean roamingEnabled)
+    {
+        super(new TestConfigFactory());
+        this.roamingEnabled = roamingEnabled;
+    }
+
+    @Override
+    public void onConnected(@NotNull ActiveConnection activeConnection)
+    {
+        if (roamingEnabled) {
+            activeConnection.setRoaming(true);
+        }
+
+        try {
+            connectionsQueue.put(activeConnection);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}