merge try

Author: JohanHiths

pom.xml

@@ -71,6 +71,13 @@
             <version>1.20.0</version>
         </dependency>
 
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <version>1.5.32</version>
+            <scope>compile</scope>
+        </dependency>
+
     </dependencies>
     <build>
         <plugins>

src/main/java/org/example/TcpServer.java

@@ -1,32 +1,33 @@
 package org.example;
 
 import org.example.http.HttpResponseBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 import java.io.OutputStream;
-import java.io.PrintWriter;
 import java.net.ServerSocket;
 import java.net.Socket;
-import java.nio.charset.StandardCharsets;
 import java.util.Map;
 
 public class TcpServer {
 
     private final int port;
     private final ConnectionFactory connectionFactory;
+    private static final Logger log = LoggerFactory.getLogger(TcpServer.class);
 
     public TcpServer(int port, ConnectionFactory connectionFactory) {
         this.port = port;
         this.connectionFactory = connectionFactory;
     }
 
     public void start() {
-        System.out.println("Starting TCP server on port " + port);
+        log.info("Starting TCP server on port {}", port);
 
         try (ServerSocket serverSocket = new ServerSocket(port)) {
             while (true) {
                 Socket clientSocket = serverSocket.accept(); // block
-                System.out.println("Client connected: " + clientSocket.getRemoteSocketAddress());
+                log.info("Client connected");
                 Thread.ofVirtual().start(() -> handleClient(clientSocket));
             }
         } catch (IOException e) {
@@ -38,16 +39,22 @@ protected void handleClient(Socket client) {
         try(client){
             processRequest(client);
         } catch (Exception e) {
-            throw new RuntimeException("Failed to close socket", e);
+            log.error("Failed when handling connection to client", e);
         }
     }
 
+    /*
+    The connection handler must be run in a try-catch-finally. Otherwise - if we use try-with-resources - the
+    connection will always be closed when code reaches handleInternalServerError() and there will never
+    be an error print on the client's webpage.
+     */
     private void processRequest(Socket client) throws Exception {
         ConnectionHandler handler = null;
         try{
             handler = connectionFactory.create(client);
             handler.runConnectionHandler();
         } catch (Exception e) {
+            log.error("Internal Server Error", e);
             handleInternalServerError(client);
         } finally {
             if(handler != null)
@@ -68,7 +75,7 @@ private void handleInternalServerError(Socket client){
                 out.write(response.build());
                 out.flush();
             } catch (IOException e) {
-                System.err.println("Failed to send 500 response: " + e.getMessage());
+                log.error("Client disconnected before 500 response could be sent", e);
             }
         }
     }

src/main/java/org/example/filter/CompressionFilter.java

@@ -1,7 +1,9 @@
 package org.example.filter;
 
+import com.aayushatharva.brotli4j.Brotli4jLoader;
 import org.example.http.HttpResponseBuilder;
 import org.example.httpparser.HttpRequest;
+import com.aayushatharva.brotli4j.encoder.Encoder;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -10,27 +12,46 @@
 import java.util.zip.GZIPOutputStream;
 
 /**
- * Compression filter that compresses HTTP responses with gzip when supported by client.
+ * Compression filter that compresses HTTP responses with gzip or Brotli when supported by client.
  *
- * <p>This filter applies gzip compression to HTTP responses when the following conditions are met:
+ * <p>This filter applies compression to HTTP responses when the following conditions are met:
  * <ul>
- *   <li>Client sends Accept-Encoding header containing "gzip"</li>
+ *   <li>Client sends Accept-Encoding header containing "gzip" or "br" (Brotli)</li>
  *   <li>Response body is larger than 1KB (MIN_COMPRESS_SIZE)</li>
  *   <li>Content-Type is compressible (text-based formats like HTML, CSS, JS, JSON)</li>
  *   <li>Content-Type is not already compressed (images, videos, zip files)</li>
  * </ul>
  *
+ * <p>Compression priority when client supports multiple algorithms:
+ * <ol>
+ *   <li>Brotli (br) - Best compression ratio</li>
+ *   <li>Gzip - Fallback if Brotli fails or not accepted</li>
+ * </ol>
+ *
  * <p>When compression is applied, the filter:
  * <ul>
- *   <li>Compresses the response body using gzip</li>
- *   <li>Sets Content-Encoding: gzip header</li>
+ *   <li>Compresses the response body using the best available algorithm</li>
+ *   <li>Sets Content-Encoding header (br or gzip)</li>
  *   <li>Sets Vary: Accept-Encoding header for proper caching</li>
  * </ul>
  *
  */
 
 public class CompressionFilter implements Filter {
     private static final int MIN_COMPRESS_SIZE = 1024;
+    private static final boolean BROTLI_AVAILABLE;
+
+    static {
+        boolean available;
+        try {
+            Brotli4jLoader.ensureAvailability();
+            available = true;
+        } catch (Exception e) {
+            available = false;
+            System.err.println("Brotli native library not available: " + e.getMessage());
+        }
+        BROTLI_AVAILABLE = available;
+    }
 
     private static final Set<String> COMPRESSIBLE_TYPES = Set.of(
             "text/html",
@@ -67,7 +88,7 @@ private void compressIfNeeded(HttpRequest request, HttpResponseBuilder response)
         }
 
         String acceptEncoding = getHeader(request, "Accept-Encoding");
-        if (acceptEncoding == null || !acceptEncoding.toLowerCase().contains("gzip")) {
+        if (acceptEncoding == null) {
             return;
         }
 
@@ -81,23 +102,72 @@ private void compressIfNeeded(HttpRequest request, HttpResponseBuilder response)
             return;
         }
 
+        if (BROTLI_AVAILABLE && isEncodingAccepted(acceptEncoding, "br")) {
+            if (tryBrotliCompression(response, originalBody)) {
+                return;
+            }
+        }
+
+        if (isEncodingAccepted(acceptEncoding, "gzip")) {
+            tryGzipCompression(response, originalBody);
+        }
+    }
+
+    private boolean isEncodingAccepted(String acceptEncoding, String encoding) {
+        String[] parts = acceptEncoding.toLowerCase().split(",");
+
+        for (String part : parts) {
+            part = part.trim();
+
+            if (part.startsWith(encoding)) {
+                if (part.contains("q=0")) {
+                    return false;
+                }
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private boolean tryBrotliCompression(HttpResponseBuilder response, byte[] originalBody) {
+        try {
+            byte[] compressed = brotliCompress(originalBody);
+
+            response.setBody(compressed);
+            response.setHeader("Content-Encoding", "br");
+            response.removeHeader("Content-Length");
+            updateVaryHeader(response);
+
+            return true;
+        } catch (IOException e) {
+            System.err.println("Brotli compression failed, falling back to gzip: " + e.getMessage());
+            return false;
+        }
+    }
+
+    private void tryGzipCompression(HttpResponseBuilder response, byte[] originalBody) {
         try {
             byte[] compressed = gzipCompress(originalBody);
 
             response.setBody(compressed);
             response.setHeader("Content-Encoding", "gzip");
-
-            String existingVary = response.getHeader("Vary");
-            if (existingVary != null && !existingVary.isEmpty()) {
-                if (!existingVary.toLowerCase().contains("accept-encoding")) {
-                    response.setHeader("Vary", existingVary + ", Accept-Encoding");
-                }
-            } else {
-                response.setHeader("Vary", "Accept-Encoding");
-            }
+            response.removeHeader("Content-Length");
+            updateVaryHeader(response);
 
         } catch (IOException e) {
-            System.err.println("CompressionFilter: gzip compression failed: " + e.getMessage());
+            System.err.println("Gzip compression failed: " + e.getMessage());
+        }
+    }
+
+    private void updateVaryHeader(HttpResponseBuilder response) {
+        String existingVary = response.getHeader("Vary");
+        if (existingVary != null && !existingVary.isEmpty()) {
+            if (!existingVary.toLowerCase().contains("accept-encoding")) {
+                response.setHeader("Vary", existingVary + ", Accept-Encoding");
+            }
+        } else {
+            response.setHeader("Vary", "Accept-Encoding");
         }
     }
 
@@ -140,6 +210,14 @@ private byte[] gzipCompress(byte[] data) throws IOException {
         return byteStream.toByteArray();
     }
 
+    private byte[] brotliCompress(byte[] data) throws IOException {
+        try {
+            return Encoder.compress(data);
+        } catch (Exception e) {
+            throw new IOException("Brotli compression failed", e);
+        }
+    }
+
     @Override
     public void destroy() {
     }