Server‑side caching Issue36

src/main/java/org/example/App.java

@@ -17,7 +17,8 @@ public static void main(String[] args) {
 
         int port = resolvePort(args, appConfig.server().port());
 
-        new TcpServer(port, ConnectionHandler::new).start();
+        FileCache fileCache = new FileCache(10);
+        new TcpServer(port, socket -> new ConnectionHandler(socket, fileCache)).start();
     }
 
     static int resolvePort(String[] args, int configPort) {

src/main/java/org/example/ConnectionHandler.java

@@ -14,22 +14,23 @@
 import java.io.IOException;
 import java.net.Socket;
 
-public class ConnectionHandler implements AutoCloseable {
+import java.io.OutputStream;
+import java.nio.file.NoSuchFileException;
 
-    Socket client;
-    String uri;
+public class ConnectionHandler implements AutoCloseable {
+    private final Socket client;
     private final List<Filter> filters;
-    String webRoot;
+    private final String webRoot;
+    private final FileCache fileCache;
 
-    public ConnectionHandler(Socket client) {
-        this.client = client;
-        this.filters = buildFilters();
-        this.webRoot = null;
+    public ConnectionHandler(Socket client, FileCache fileCache) {
+        this(client, "www", fileCache);
     }
 
-    public ConnectionHandler(Socket client, String webRoot) {
+    public ConnectionHandler(Socket client, String webRoot, FileCache fileCache) {
         this.client = client;
         this.webRoot = webRoot;
+        this.fileCache = fileCache;
         this.filters = buildFilters();
     }
 
@@ -40,67 +41,73 @@ private List<Filter> buildFilters() {
         if (Boolean.TRUE.equals(ipFilterConfig.enabled())) {
             list.add(createIpFilterFromConfig(ipFilterConfig));
         }
-        // Add more filters here...
         return list;
     }
 
     public void runConnectionHandler() throws IOException {
-        StaticFileHandler sfh;
+        HttpParser parser = parseRequest();
+        HttpRequest request = buildHttpRequest(parser);
 
-        if (webRoot != null) {
-            sfh = new StaticFileHandler(webRoot);
-        } else {
-            sfh = new StaticFileHandler();
-        }
+        if (isForbiddenByFilters(request)) return;
+        if (isPathTraversal(parser.getUri())) return;
+
+        serveFile(parser.getUri());
+    }
 
+    private HttpParser parseRequest() throws IOException {
         HttpParser parser = new HttpParser();
         parser.setReader(client.getInputStream());
         parser.parseRequest();
         parser.parseHttp();
+        return parser;
+    }
 
+    private HttpRequest buildHttpRequest(HttpParser parser) {
         HttpRequest request = new HttpRequest(
-                parser.getMethod(),
-                parser.getUri(),
-                parser.getVersion(),
-                parser.getHeadersMap(),
-                ""
+                parser.getMethod(), parser.getUri(), parser.getVersion(),
+                parser.getHeadersMap(), ""
         );
+        request.setAttribute("clientIp", client.getInetAddress().getHostAddress());
+        return request;
+    }
 
-        String clientIp = client.getInetAddress().getHostAddress();
-        request.setAttribute("clientIp", clientIp);
-
-        HttpResponseBuilder response = applyFilters(request);
+    private boolean isForbiddenByFilters(HttpRequest request) throws IOException {
+        HttpResponseBuilder response = new HttpResponseBuilder();
+        new FilterChainImpl(filters).doFilter(request, response);
 
-        int statusCode = response.getStatusCode();
-        if (statusCode == HttpResponseBuilder.SC_FORBIDDEN ||
-                statusCode == HttpResponseBuilder.SC_BAD_REQUEST) {
-            byte[] responseBytes = response.build();
-            client.getOutputStream().write(responseBytes);
+        int status = response.getStatusCode();
+        if (status == HttpResponseBuilder.SC_FORBIDDEN || status == HttpResponseBuilder.SC_BAD_REQUEST) {
+            client.getOutputStream().write(response.build());
             client.getOutputStream().flush();
-            return;
+            return true;
         }
-
-        resolveTargetFile(parser.getUri());
-        sfh.sendGetRequest(client.getOutputStream(), uri);
+        return false;
     }
 
-    private HttpResponseBuilder applyFilters(HttpRequest request) {
-        HttpResponseBuilder response = new HttpResponseBuilder();
-
-        FilterChainImpl chain = new FilterChainImpl(filters);
-        chain.doFilter(request, response);
-
-        return response;
+    private boolean isPathTraversal(String uri) throws IOException {
+        if (uri.contains("..")) {
+            sendErrorResponse(client.getOutputStream(), 403, "Forbidden");
+            return true;
+        }
+        return false;
     }
 
-    private void resolveTargetFile(String uri) {
-        if (uri == null || "/".equals(uri)) {
-            this.uri = "index.html";
-        } else {
-            this.uri = uri.startsWith("/") ? uri.substring(1) : uri;
+    private void serveFile(String uri) throws IOException {
+        StaticFileHandler sfh = new StaticFileHandler(webRoot, fileCache);
+        try {
+            sfh.sendGetRequest(client.getOutputStream(), uri);
+        } catch (NoSuchFileException e) {
+            sendErrorResponse(client.getOutputStream(), 404, "Not Found");
+        } catch (Exception e) {
+            sendErrorResponse(client.getOutputStream(), 500, "Internal Server Error");
         }
     }
 
+    private void sendErrorResponse(OutputStream out, int statusCode, String message) throws IOException {
+        out.write(HttpResponseBuilder.createErrorResponse(statusCode, message));
+        out.flush();
+    }
+
     @Override
     public void close() throws Exception {
         client.close();
@@ -109,19 +116,16 @@ public void close() throws Exception {
     private IpFilter createIpFilterFromConfig(AppConfig.IpFilterConfig config) {
         IpFilter filter = new IpFilter();
 
-        // Set mode
         if ("ALLOWLIST".equalsIgnoreCase(config.mode())) {
             filter.setMode(IpFilter.FilterMode.ALLOWLIST);
         } else {
             filter.setMode(IpFilter.FilterMode.BLOCKLIST);
         }
 
-        // Add blocked IPs
         for (String ip : config.blockedIps()) {
             filter.addBlockedIp(ip);
         }
 
-        // Add allowed IPs
         for (String ip : config.allowedIps()) {
             filter.addAllowedIp(ip);
         }

src/main/java/org/example/FileCache.java

@@ -0,0 +1,24 @@
+package org.example;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class FileCache {
+    private final Map<String, byte[]> cache;
+
+    public FileCache(int maxSize) {
+        this.cache = Collections.synchronizedMap(new LinkedHashMap<String, byte[]>(maxSize, 0.75f, true) {
+            @Override
+            protected boolean removeEldestEntry(Map.Entry<String, byte[]> eldest) {
+                return size() > maxSize;
+            }
+        });
+    }
+
+    public byte[] get(String key) { return cache.get(key); }
+    public void put(String key, byte[] content) { cache.put(key, content); }
+    public void clear() { cache.clear(); }
+    public int size() { return cache.size(); }
+}
+

src/main/java/org/example/StaticFileHandler.java

@@ -1,69 +1,58 @@
+
 package org.example;
 
 import org.example.http.HttpResponseBuilder;
-import static org.example.http.HttpResponseBuilder.*;
-
-import java.io.File;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.file.Files;
+import java.nio.file.Path;
 
 public class StaticFileHandler {
-    private final String WEB_ROOT;
-    private byte[] fileBytes;
-    private int statusCode;
+    private static final String DEFAULT_WEB_ROOT = "www";
+    private final String webRoot;
+    private final FileCache fileCache;
 
-    // Constructor for production
-    public StaticFileHandler() {
-        WEB_ROOT = "www";
+    public StaticFileHandler(FileCache fileCache) {
+        this(DEFAULT_WEB_ROOT, fileCache);
     }
 
-    // Constructor for tests, otherwise the www folder won't be seen
-    public StaticFileHandler(String webRoot) {
-        WEB_ROOT = webRoot;
+    public StaticFileHandler(String webRoot, FileCache fileCache) {
+        this.webRoot = webRoot;
+        this.fileCache = fileCache;
     }
 
-    private void handleGetRequest(String uri) throws IOException {
-        // Sanitize URI
-        int q = uri.indexOf('?');
-        if (q >= 0) uri = uri.substring(0, q);
-        int h = uri.indexOf('#');
-        if (h >= 0) uri = uri.substring(0, h);
-        uri = uri.replace("\0", "");
-        if (uri.startsWith("/")) uri = uri.substring(1);
+    public void sendGetRequest(OutputStream outputStream, String uri) throws IOException {
+        String sanitizedUri = sanitizeUri(uri);
+        Path filePath = Path.of(webRoot, sanitizedUri);
 
-        // Path traversal check
-        File root = new File(WEB_ROOT).getCanonicalFile();
-        File file = new File(root, uri).getCanonicalFile();
-        if (!file.toPath().startsWith(root.toPath())) {
-            fileBytes = "403 Forbidden".getBytes(java.nio.charset.StandardCharsets.UTF_8);
-            statusCode = SC_FORBIDDEN;
-            return;
-        }
+        // Använd fullständig sökväg som cache-nyckel
+        String cacheKey = filePath.toString();
+        byte[] fileBytes = fileCache.get(cacheKey);
 
-        // Read file
-        if (file.isFile()) {
-            fileBytes = Files.readAllBytes(file.toPath());
-            statusCode = SC_OK;
-        } else {
-            File errorFile = new File(WEB_ROOT, "pageNotFound.html");
-            if (errorFile.isFile()) {
-                fileBytes = Files.readAllBytes(errorFile.toPath());
-            } else {
-                fileBytes = "404 Not Found".getBytes(java.nio.charset.StandardCharsets.UTF_8);
-            }
-            statusCode = SC_NOT_FOUND;
+        if (fileBytes == null) {
+            fileBytes = Files.readAllBytes(filePath);
+            fileCache.put(cacheKey, fileBytes);
         }
-    }
 
-    public void sendGetRequest(OutputStream outputStream, String uri) throws IOException {
-        handleGetRequest(uri);
         HttpResponseBuilder response = new HttpResponseBuilder();
-        response.setStatusCode(statusCode);
-        // Use MimeTypeDetector instead of hardcoded text/html
-        response.setContentTypeFromFilename(uri);
+        response.setContentTypeFromFilename(sanitizedUri);
         response.setBody(fileBytes);
         outputStream.write(response.build());
         outputStream.flush();
     }
+
+    private String sanitizeUri(String uri) {
+        if (uri == null || uri.isEmpty() || uri.equals("/")) return "index.html";
+
+        // Ta bort query, anchors, start-snedstreck och null-bytes
+        String cleanUri = uri.split("[?#]")[0]
+                .replaceAll("^/+", "")
+                .replace("\0", "");
+
+        return cleanUri.isEmpty() ? "index.html" : cleanUri;
+    }
+
+    public void clearCache() {
+        fileCache.clear();
+    }
 }

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

@@ -4,11 +4,8 @@
 
 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 {
 
@@ -43,29 +40,19 @@ protected void handleClient(Socket client) {
     }
 
     private void processRequest(Socket client) throws Exception {
-        ConnectionHandler handler = null;
-        try{
-            handler = connectionFactory.create(client);
+        try (ConnectionHandler handler = connectionFactory.create(client)) {
             handler.runConnectionHandler();
         } catch (Exception e) {
             handleInternalServerError(client);
-        } finally {
-            if(handler != null)
-                handler.close();
         }
     }
 
 
     private void handleInternalServerError(Socket client){
-        HttpResponseBuilder response = new HttpResponseBuilder();
-        response.setStatusCode(HttpResponseBuilder.SC_INTERNAL_SERVER_ERROR);
-        response.setHeaders(Map.of("Content-Type", "text/plain; charset=utf-8"));
-        response.setBody("⚠️ Internal Server Error 500 ⚠️");
-
         if (!client.isClosed()) {
             try {
                 OutputStream out = client.getOutputStream();
-                out.write(response.build());
+                out.write(HttpResponseBuilder.createErrorResponse(500, "Internal Server Error"));
                 out.flush();
             } catch (IOException e) {
                 System.err.println("Failed to send 500 response: " + e.getMessage());

src/main/java/org/example/http/HttpResponseBuilder.java

@@ -93,6 +93,18 @@ public void setContentTypeFromFilename(String filename) {
         setHeader("Content-Type", mimeType);
     }
 
+    public void setError(int statusCode, String message) {
+        setStatusCode(statusCode);
+        setHeader("Content-Type", "text/html; charset=UTF-8");
+        setBody(String.format("<html><body><h1>%d %s</h1></body></html>", statusCode, message));
+    }
+
+    public static byte[] createErrorResponse(int statusCode, String message) {
+        HttpResponseBuilder builder = new HttpResponseBuilder();
+        builder.setError(statusCode, message);
+        return builder.build();
+    }
+
     /*
      * Builds the complete HTTP response as a byte array and preserves binary content without corruption.
      * @return Complete HTTP response (headers + body) as byte[]