refactor(channel): Simply how packets are handled

fix(packet): Fix misreporting of packet sizes in one of the write functions

Author: velitasali

README.md

@@ -23,11 +23,11 @@ public class Main
         CoolSocket coolSocket = new CoolSocket(port)
         {
             @Override
-            public void onConnected(ActiveConnection activeConnection)
+            public void onConnected(ActiveConnection channel)
             {
                 try {
-                    activeConnection.reply("Hello!");
-                    System.out.println(activeConnection.receive().getAsString()); // Merhaba!
+                    channel.reply("Hello!");
+                    System.out.println(channel.receive().getAsString()); // Merhaba!
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
@@ -36,9 +36,9 @@ public class Main
 
         coolSocket.start();
 
-        try (ActiveConnection activeConnection = ActiveConnection.connect(new InetSocketAddress(port), 0)) {
-            System.out.println(activeConnection.receive().getAsString()); // "Hello!"
-            activeConnection.reply("Merhaba!");
+        try (ActiveConnection channel = ActiveConnection.connect(new InetSocketAddress(port), 0)) {
+            System.out.println(channel.receive().getAsString()); // "Hello!"
+            channel.reply("Merhaba!");
         } finally {
             coolSocket.stop();   
         }

pom.xml

@@ -157,11 +157,6 @@
         </profile>
     </profiles>
     <dependencies>
-        <dependency>
-            <groupId>org.json</groupId>
-            <artifactId>json</artifactId>
-            <version>20230618</version>
-        </dependency>
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>

src/main/java/org/monora/coolsocket/core/client/ClientHandler.java

@@ -1,7 +1,7 @@
 package org.monora.coolsocket.core.client;
 
 import org.jetbrains.annotations.NotNull;
-import org.monora.coolsocket.core.session.ActiveConnection;
+import org.monora.coolsocket.core.session.Channel;
 
 /**
  * This class handles the last sequence of a client connection which is to answer to it.
@@ -13,9 +13,9 @@ public interface ClientHandler
     /**
      * When a client is connected, this method will be called.
      *
-     * @param activeConnection The connection object that represents the client.
+     * @param channel The connection object that represents the client.
      */
-    default void onConnected(@NotNull ActiveConnection activeConnection)
+    default void onConnected(@NotNull Channel channel)
     {
 
     }

src/main/java/org/monora/coolsocket/core/config/Config.java

@@ -15,11 +15,6 @@ public final class Config
      */
     public static final int DEFAULT_BUFFER_SIZE = 8192;
 
-    /**
-     * The default internal cache size spared for polling requests in memory.
-     */
-    public static final int DEFAULT_INTERNAL_CACHE_SIZE = 0x100000;
-
     /**
      * The default inverse exchange point number.
      * <p>

src/main/java/org/monora/coolsocket/core/config/ConfigFactory.java

@@ -1,7 +1,7 @@
 package org.monora.coolsocket.core.config;
 
 import org.jetbrains.annotations.NotNull;
-import org.monora.coolsocket.core.session.ActiveConnection;
+import org.monora.coolsocket.core.session.Channel;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -32,14 +32,14 @@ public interface ConfigFactory
     ServerSocket createServer() throws IOException;
 
     /**
-     * Configure the socket connection to a client before its actual usage and produce an {@link ActiveConnection}
+     * Configure the socket connection to a client before its actual usage and produce an {@link Channel}
      * instance. The configuration may be different from that of {@link ServerSocket#accept()} assigns.
      *
      * @param client To configure.
-     * @return The configured socket encapsulated in a {@link ActiveConnection}.
+     * @return The configured socket encapsulated in a {@link Channel}.
      * @throws SocketException When an unrecoverable error occurs due to misconfiguration.
      */
-    ActiveConnection configureClient(@NotNull Socket client) throws SocketException;
+    Channel configureClient(@NotNull Socket client) throws IOException;
 
     /**
      * The address that the upcoming products will be assigned to. This does not necessarily reflect the address

src/main/java/org/monora/coolsocket/core/config/DefaultConfigFactory.java

@@ -1,7 +1,7 @@
 package org.monora.coolsocket.core.config;
 
 import org.jetbrains.annotations.NotNull;
-import org.monora.coolsocket.core.session.ActiveConnection;
+import org.monora.coolsocket.core.session.Channel;
 
 import java.io.IOException;
 import java.net.ServerSocket;
@@ -30,9 +30,10 @@ public void configureServer(@NotNull ServerSocket serverSocket) throws IOExcepti
     }
 
     @Override
-    public @NotNull ActiveConnection configureClient(@NotNull Socket socket) throws SocketException
+    public @NotNull Channel configureClient(@NotNull Socket socket) throws IOException
     {
-        return new ActiveConnection(socket, readTimeout);
+        socket.setSoTimeout(readTimeout);
+        return Channel.wrap(socket);
     }
 
     @Override

src/main/java/org/monora/coolsocket/core/response/Flags.java

@@ -8,7 +8,7 @@
 public class Flags
 {
     /**
-     * Bit order: 0
+     * The bit order: 0
      * <p>
      * Tells that the read is inconclusive and another read is needed. If the data is not chunked, then, the data will
      * be read as many as its length.

src/main/java/org/monora/coolsocket/core/response/Response.java

@@ -1,9 +1,7 @@
 package org.monora.coolsocket.core.response;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.json.JSONObject;
-import org.monora.coolsocket.core.session.ActiveConnection;
+import org.monora.coolsocket.core.session.Channel;
 
 import java.io.ByteArrayOutputStream;
 import java.io.OutputStream;
@@ -13,75 +11,45 @@
 /**
  * This class represents the response received from the remote client that the CoolSocket is connected to.
  *
- * @see ActiveConnection#receive(OutputStream)
+ * @see Channel#receive(OutputStream)
  */
-public class Response
-{
+public class Response {
     /**
      * The remote that sent the response.
      */
     public final @NotNull SocketAddress remote;
 
     /**
-     * The feature flags set for this part.
+     * The flags set for the response.
      */
     public final @NotNull Flags flags;
 
     /**
-     * The length of the data received for this part. This will also be the total length of a chunked data.
+     * The total length of the data.
      */
     public final long length;
 
     /**
-     * If the received data is small in size, and is written to a byte buffer (e.g., {@link ByteArrayOutputStream}),
-     * it will be included in this field.
+     * The data.
      */
-    public final @Nullable ByteArrayOutputStream data;
+    public final @NotNull ByteArrayOutputStream data;
 
     /**
      * Creates a new Response instance.
      *
      * @param remote Where the remote is located at.
      * @param flags  The feature flags for this response.
      * @param length The total length of the data.
-     * @param data   The byte data stored in the heap.
+     * @param data   The data.
      */
     public Response(@NotNull SocketAddress remote, @NotNull Flags flags, long length,
-                    @Nullable ByteArrayOutputStream data)
-    {
+                    @NotNull ByteArrayOutputStream data) {
         this.remote = remote;
         this.flags = flags;
         this.length = length;
         this.data = data;
     }
 
-    /**
-     * Check whether the data contains actual data.
-     *
-     * @return True if the data is actually an object.
-     */
-    public boolean containsData()
-    {
-        return data != null;
-    }
-
-    public @NotNull JSONObject getAsJson()
-    {
-        return new JSONObject(getAsString());
-    }
-
-    /**
-     * Get the data as a JSON object.
-     *
-     * @param charsetName The name of the charset to use to decode the data.
-     * @return The encapsulated JSON data.
-     * @throws UnsupportedEncodingException If the supplied charset name is not available.
-     */
-    public @NotNull JSONObject getAsJson(@NotNull String charsetName) throws UnsupportedEncodingException
-    {
-        return new JSONObject(getAsString(charsetName));
-    }
-
     /**
      * Return the data as a string.
      *
@@ -90,11 +58,7 @@ public boolean containsData()
      * @throws UnsupportedEncodingException If the supplied charset name is not available.
      * @see #getAsString()
      */
-    public @NotNull String getAsString(@NotNull String charsetName) throws UnsupportedEncodingException
-    {
-        if (data == null) {
-            throw new IllegalStateException("Trying to read data from a response whose data point is separate.");
-        }
+    public @NotNull String getAsString(@NotNull String charsetName) throws UnsupportedEncodingException {
         return data.toString(charsetName);
     }
 
@@ -104,11 +68,15 @@ public boolean containsData()
      * @return The string representation of the {@link #data}.
      * @see #getAsString(String)
      */
-    public @NotNull String getAsString()
-    {
-        if (data == null) {
-            throw new IllegalStateException("Trying to read data from a response whose data point is separate.");
-        }
+    public @NotNull String getAsString() {
         return data.toString();
     }
+
+    /**
+     * Get the raw data.
+     * @return The raw data.
+     */
+    public @NotNull byte[] getBytes() {
+        return data.toByteArray();
+    }
 }

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

@@ -2,7 +2,7 @@
 
 import org.jetbrains.annotations.NotNull;
 import org.monora.coolsocket.core.CoolSocket;
-import org.monora.coolsocket.core.session.ActiveConnection;
+import org.monora.coolsocket.core.session.Channel;
 
 import java.net.InetAddress;
 import java.util.List;
@@ -18,12 +18,12 @@ public interface ConnectionManager
     int CLOSING_CONTRACT_CLOSE_IMMEDIATELY = 1;
 
     /**
-     * Close using {@link ActiveConnection#closeSafely()} which will inform the remote and close the connection.
+     * Close using {@link Channel#closeMutually()} which will inform the remote and close the connection.
      */
     int CLOSING_CONTRACT_CLOSE_SAFELY = 2;
 
     /**
-     * Cancel the ongoing operations informing the remote about it using {@link ActiveConnection#cancel()}. This doesn't
+     * Cancel the ongoing operations informing the remote about it using {@link Channel#cancel()}. This doesn't
      * guarantee that the connections will be closed. If both sides of a connection want, the existing connection can
      * still be maintained after the cancel request is handled.
      */
@@ -45,17 +45,17 @@ public interface ConnectionManager
      * Handle a client connection assigning it to a thread that will execute it asynchronously.
      *
      * @param coolSocket       The calling CoolSocket instance.
-     * @param activeConnection To handle.
+     * @param channel To handle.
      */
-    void handleClient(@NotNull CoolSocket coolSocket, @NotNull ActiveConnection activeConnection);
+    void handleClient(@NotNull CoolSocket coolSocket, @NotNull Channel channel);
 
     /**
      * Returns the list of active connections that are still ongoing. This list does not hold the connections that are
      * closed.
      *
      * @return A copy list of active connections that are still alive.
      */
-    List<@NotNull ActiveConnection> getActiveConnectionList();
+    List<@NotNull Channel> getActiveConnectionList();
 
     /**
      * Counts the total connection of a client to the CoolSocket server.
@@ -67,8 +67,8 @@ default int getConnectionCountByAddress(@NotNull InetAddress address)
     {
         int returnObject = 0;
 
-        for (ActiveConnection activeConnection : getActiveConnectionList())
-            if (activeConnection.getAddress().equals(address))
+        for (Channel channel : getActiveConnectionList())
+            if (channel.getSocket().getInetAddress().equals(address))
                 returnObject++;
 
         return returnObject;

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

@@ -2,7 +2,7 @@
 
 import org.jetbrains.annotations.NotNull;
 import org.monora.coolsocket.core.CoolSocket;
-import org.monora.coolsocket.core.session.ActiveConnection;
+import org.monora.coolsocket.core.session.Channel;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -14,7 +14,7 @@
 
 public class DefaultConnectionManager implements ConnectionManager
 {
-    private final @NotNull List<@NotNull ActiveConnection> connectionList = new ArrayList<>();
+    private final @NotNull List<@NotNull Channel> connectionList = new ArrayList<>();
 
     private final @NotNull ExecutorService executorService = Executors.newFixedThreadPool(10);
 
@@ -33,14 +33,14 @@ public void closeAll()
 
         if (closingContract != CLOSING_CONTRACT_DO_NOTHING) {
             synchronized (connectionList) {
-                for (ActiveConnection connection : connectionList) {
+                for (Channel connection : connectionList) {
                     try {
                         switch (contract) {
                             case CLOSING_CONTRACT_CANCEL:
                                 connection.cancel();
                                 break;
                             case CLOSING_CONTRACT_CLOSE_SAFELY:
-                                connection.closeSafely();
+                                connection.closeMutually();
                                 break;
                             case CLOSING_CONTRACT_CLOSE_IMMEDIATELY:
                             default:
@@ -64,34 +64,34 @@ public void closeAll()
     }
 
     @Override
-    public void handleClient(@NotNull CoolSocket coolSocket, final @NotNull ActiveConnection activeConnection)
+    public void handleClient(@NotNull CoolSocket coolSocket, final @NotNull Channel channel)
     {
         synchronized (connectionList) {
-            connectionList.add(activeConnection);
+            connectionList.add(channel);
         }
 
         executorService.submit(() -> {
             try {
-                coolSocket.getClientHandler().onConnected(activeConnection);
+                coolSocket.getClientHandler().onConnected(channel);
             } catch (Exception e) {
                 coolSocket.getLogger().log(Level.SEVERE, "An error occurred during handling of a client", e);
             } finally {
-                if (!activeConnection.isRoaming()) {
+                if (!channel.isRoaming()) {
                     try {
-                        activeConnection.close();
+                        channel.close();
                     } catch (IOException ignored) {
                     }
                 }
 
                 synchronized (connectionList) {
-                    connectionList.remove(activeConnection);
+                    connectionList.remove(channel);
                 }
             }
         });
     }
 
     @Override
-    public @NotNull List<@NotNull ActiveConnection> getActiveConnectionList()
+    public @NotNull List<@NotNull Channel> getActiveConnectionList()
     {
         return new ArrayList<>(connectionList);
     }