Gjort det coderabbit bätt mig om

Boppler12 · Boppler12 · commit 704f8d849858 · 2026-02-25T13:52:20.000+01:00
diff --git a/src/main/java/org/example/CacheFilter.java b/src/main/java/org/example/CacheFilter.java
@@ -1,4 +1,3 @@
-
 package org.example;
 
 import java.io.IOException;
@@ -7,6 +6,8 @@
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.logging.Logger;
 import java.util.logging.Level;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
 
 /**
  * Thread-safe in-memory cache filter using ConcurrentHashMap
@@ -55,7 +56,7 @@ public byte[] getOrFetch(String uri, FileProvider provider) throws IOException {
         CacheEntry entry = cache.get(uri);
         if (entry != null) {
             entry.recordAccess();
-            LOGGER.log(Level.FINE, "✓ Cache hit for: " + uri);
+            LOGGER.log(Level.FINE, " Cache hit for: " + uri);
             return entry.data;
         }
 
@@ -65,14 +66,14 @@ public byte[] getOrFetch(String uri, FileProvider provider) throws IOException {
             entry = cache.get(uri);
             if (entry != null) {
                 entry.recordAccess();
-                LOGGER.log(Level.FINE, "✓ Cache hit for: " + uri + " (from concurrent fetch)");
+                LOGGER.log(Level.FINE, "Cache hit for: " + uri + " (from concurrent fetch)");
                 return entry.data;
             }
             
             
 
             // Fetch och cachelagra
-            LOGGER.log(Level.FINE, "✗ Cache miss for: " + uri);
+            LOGGER.log(Level.FINE, "Cache miss for: " + uri);
             byte[] fileBytes = provider.fetch(uri);
 
             if (fileBytes != null) {
@@ -86,7 +87,7 @@ public byte[] getOrFetch(String uri, FileProvider provider) throws IOException {
     private void addToCacheUnsafe(String uri, byte[] data) {
         // Guard mot oversized entries som kan blockera eviction
         if (data.length > MAX_CACHE_BYTES) {
-            LOGGER.log(Level.WARNING, "⚠️ Skipping cache for oversized file: " + uri +
+            LOGGER.log(Level.WARNING, "Skipping cache for oversized file: " + uri +
                     " (" + (data.length / 1024 / 1024) + "MB > " +
                     (MAX_CACHE_BYTES / 1024 / 1024) + "MB)");
             return;
@@ -99,7 +100,7 @@ private void addToCacheUnsafe(String uri, byte[] data) {
 
         // Om cache fortfarande är full efter eviction, hoppa över
         if (shouldEvict(data)) {
-            LOGGER.log(Level.WARNING, "⚠️ Cache full, skipping: " + uri);
+            LOGGER.log(Level.WARNING, " Cache full, skipping: " + uri);
             return;
         }
 
@@ -137,7 +138,7 @@ private void evictLeastRecentlyUsedUnsafe() {
             CacheEntry removed = cache.remove(keyToRemove);
             if (removed != null) {
                 currentBytes.addAndGet(-removed.data.length);
-                LOGGER.log(Level.FINE, "✗ Evicted from cache: " + keyToRemove +
+                LOGGER.log(Level.FINE, " Evicted from cache: " + keyToRemove +
                         " (accesses: " + removed.accessCount.get() + ")");
             }
         }
@@ -153,19 +154,79 @@ public void clearCache() {
             currentBytes.set(0);
         }
     }
-
+    /**
+     * Cache statistics record.
+     */
     @Override
-    public CacheStats getStats() {
-        long totalAccesses = cache.values().stream()
-                .mapToLong(e -> e.accessCount.get())
-                .sum();
-
-        return new CacheStats(
-                cache.size(),
-                currentBytes.get(),
-                MAX_CACHE_ENTRIES,
-                MAX_CACHE_BYTES,
-                totalAccesses
+    public FileCache.CacheStats getStats() {
+        return null;
+    }
+
+
+    class CacheStats {
+        public final int entries;
+        public final long bytes;
+        public final int maxEntries;
+        public final long maxBytes;
+        public final long totalAccesses;
+
+        public CacheStats(int entries, long bytes, int maxEntries, long maxBytes, long totalAccesses) {
+            this.entries = entries;
+            this.bytes = bytes;
+            this.maxEntries = maxEntries;
+            this.maxBytes = maxBytes;
+            this.totalAccesses = totalAccesses;
+        }
+
+        @Override
+        public String toString() {
+            String bytesFormatted = formatBytes(bytes);
+            String maxBytesFormatted = formatBytes(maxBytes);
+            
+            return String.format(
+                    "CacheStats{entries=%d/%d, bytes=%s/%s, utilization=%.1f%%, accesses=%d}",
+                    entries, maxEntries, bytesFormatted, maxBytesFormatted,
+                    (double) bytes / maxBytes * 100, totalAccesses
+            );
+        }
+
+        private static String formatBytes(long bytes) {
+            if (bytes <= 0) return "0 B";
+            final String[] units = new String[]{"B", "KB", "MB", "GB"};
+            int digitGroups = (int) (Math.log10(bytes) / Math.log10(1024));
+            return String.format("%.1f %s", bytes / Math.pow(1024, digitGroups), units[digitGroups]);
+        }
+    }
+
+    /**
+     * Sanitizes URI by removing query strings, fragments, null bytes, and leading slashes.
+     * Also performs URL-decoding to normalize percent-encoded sequences.
+     */
+    private String sanitizeUri(String uri) {
+        if (uri == null || uri.isEmpty()) {
+            return "index.html";
+        }
+
+        // Ta bort query string och fragment
+        int queryIndex = uri.indexOf('?');
+        int fragmentIndex = uri.indexOf('#');
+        int endIndex = Math.min(
+                queryIndex > 0 ? queryIndex : uri.length(),
+                fragmentIndex > 0 ? fragmentIndex : uri.length()
         );
+
+        uri = uri.substring(0, endIndex)
+                .replace("\0", "")
+                .replaceAll("^/+", "");  // Bort med leading slashes
+
+        // URL-decode för att normalisera percent-encoded sequences (t.ex. %2e%2e -> ..)
+        try {
+            uri = URLDecoder.decode(uri, StandardCharsets.UTF_8);
+        } catch (IllegalArgumentException e) {
+            LOGGER.log(Level.WARNING, "Ogiltig URL-kodning i URI: " + uri);
+            // Returna som den är om avkodning misslyckas; isPathTraversal kommer hantera det
+        }
+
+        return uri.isEmpty() ? "index.html" : uri;
     }
 }
diff --git a/src/main/java/org/example/FileCache.java b/src/main/java/org/example/FileCache.java
@@ -56,11 +56,21 @@ public CacheStats(int entries, long bytes, int maxEntries, long maxBytes, long t
 
         @Override
         public String toString() {
+            String bytesFormatted = formatBytes(bytes);
+            String maxBytesFormatted = formatBytes(maxBytes);
+            
             return String.format(
-                    "CacheStats{entries=%d/%d, bytes=%d/%d, utilization=%.1f%%, accesses=%d}",
-                    entries, maxEntries, bytes, maxBytes,
+                    "CacheStats{entries=%d/%d, bytes=%s/%s, utilization=%.1f%%, accesses=%d}",
+                    entries, maxEntries, bytesFormatted, maxBytesFormatted,
                     (double) bytes / maxBytes * 100, totalAccesses
             );
         }
+
+        private static String formatBytes(long bytes) {
+            if (bytes <= 0) return "0 B";
+            final String[] units = new String[]{"B", "KB", "MB", "GB"};
+            int digitGroups = (int) (Math.log10(bytes) / Math.log10(1024));
+            return String.format("%.1f %s", bytes / Math.pow(1024, digitGroups), units[digitGroups]);
+        }
     }
 }
diff --git a/src/main/java/org/example/StaticFileHandler.java b/src/main/java/org/example/StaticFileHandler.java
@@ -74,7 +74,11 @@ private String generateCacheKey(String sanitizedUri) {
      * Also performs URL-decoding to normalize percent-encoded sequences.
      */
     private String sanitizeUri(String uri) {
-        // Entydlig: ta bort query string och fragment
+        if (uri == null || uri.isEmpty()) {
+            return "index.html";
+        }
+
+        // Ta bort query string och fragment
         int queryIndex = uri.indexOf('?');
         int fragmentIndex = uri.indexOf('#');
         int endIndex = Math.min(
@@ -86,18 +90,17 @@ private String sanitizeUri(String uri) {
                 .replace("\0", "")
                 .replaceAll("^/+", "");  // Bort med leading slashes
 
-        // URL-decode to normalize percent-encoded sequences (e.g., %2e%2e -> ..)
+        // URL-decode för att normalisera percent-encoded sequences (t.ex. %2e%2e -> ..)
         try {
             uri = URLDecoder.decode(uri, StandardCharsets.UTF_8);
         } catch (IllegalArgumentException e) {
-            LOGGER.log(Level.WARNING, "Invalid URL encoding in URI: " + uri);
-            // Return as-is if decoding fails; isPathTraversal will handle it
+            LOGGER.log(Level.WARNING, "Ogiltig URL-kodning i URI: " + uri);
+            // Returna som den är om avkodning misslyckas; isPathTraversal kommer hantera det
         }
 
-        return uri;
+        return uri.isEmpty() ? "index.html" : uri;
     }
 
-    /**
     /**
      * Kontrollerar om den begärda sökvägen försöker traversera utanför webroten.
      * Använder sökvägsnormalisering efter avkodning för att fånga traversalförsök.
diff --git a/src/test/java/org/example/StaticFileHandlerTest.java b/src/test/java/org/example/StaticFileHandlerTest.java
@@ -85,29 +85,30 @@ void testConcurrent_MultipleReads() throws InterruptedException, IOException {
         Files.writeString(tempDir.resolve("shared.html"), "Data");
         StaticFileHandler handler = new StaticFileHandler(tempDir.toString());
 
-        // Förvärmning
+        // Förvärmning - ladda filen i cache
         handler.sendGetRequest(new ByteArrayOutputStream(), "shared.html");
 
-        // Act - 10 trådar läser samma fil 50 gånger varje
+        // Act - 10 trådar läser samma fil 50 gånger varje = 500 totala läsningar
         Thread[] threads = new Thread[10];
-        final AssertionError[] assertionErrors = new AssertionError[1];
+        final Exception[] threadError = new Exception[1];
 
         for (int i = 0; i < 10; i++) {
             threads[i] = new Thread(() -> {
                 try {
                     for (int j = 0; j < 50; j++) {
                         ByteArrayOutputStream out = new ByteArrayOutputStream();
                         handler.sendGetRequest(out, "shared.html");
-                        assertThat(out.toString()).contains("HTTP/1.1 200");
+                        String response = out.toString();
+                        
+                        // Validera att svaret är korrekt
+                        if (!response.contains("HTTP/1.1 200") || !response.contains("Data")) {
+                            throw new AssertionError("Oväntad response: " + response.substring(0, Math.min(100, response.length())));
+                        }
                     }
-                } catch (IOException e) {
-                    throw new RuntimeException(e);
-                } catch (AssertionError e) {
-                    // Capture assertion errors from child thread
+                } catch (Exception e) {
                     synchronized (threads) {
-                        assertionErrors[0] = e;
+                        threadError[0] = e;
                     }
-                    throw e;
                 }
             });
             threads[i].start();
@@ -118,13 +119,15 @@ void testConcurrent_MultipleReads() throws InterruptedException, IOException {
             t.join();
         }
 
-        // Assert - Check if any child thread had assertion failures
-        if (assertionErrors[0] != null) {
-            throw assertionErrors[0];
+        // Assert - Kontrollera om någon tråd hade fel
+        if (threadError[0] != null) {
+            throw new AssertionError("Tråd-fel: " + threadError[0].getMessage(), threadError[0]);
         }
 
-        // Assert - Cache ska bara ha EN entry
-        assertThat(StaticFileHandler.getCacheStats().entries).isEqualTo(1);
+        // Assert - Cache ska bara ha EN entry för shared.html
+        FileCache.CacheStats stats = StaticFileHandler.getCacheStats();
+        assertThat(stats.entries).isEqualTo(1);
+        assertThat(stats.totalAccesses).isGreaterThanOrEqualTo(500);
     }
 
     @Test
