Merge remote-tracking branch 'origin/main' into Implement-Configurable-Filter-Pipeline-(Global-+-Per‑Route-Filters)

Author: viktorlindell12

Dockerfile

@@ -9,8 +9,8 @@ FROM eclipse-temurin:25-jre-alpine
 EXPOSE 8080
 RUN addgroup -S appgroup && adduser -S appuser -G appgroup
 WORKDIR /app/
-COPY --from=build /build/target/classes/ /
-COPY --from=build /build/target/dependency/ /dependencies/
-COPY /www/ /www/
+COPY --from=build /build/target/classes/ /app/
+COPY --from=build /build/target/dependency/ /app/dependencies/
+COPY www/ ./www/
 USER appuser
-ENTRYPOINT ["java", "-classpath", "/app:/dependencies/*", "org.example.App"]
+ENTRYPOINT ["java", "-classpath", "/app:/app/dependencies/*", "org.example.App"]

pom.xml

@@ -65,6 +65,11 @@
             <artifactId>jackson-dataformat-yaml</artifactId>
             <version>3.0.3</version>
         </dependency>
+        <dependency>
+            <groupId>com.aayushatharva.brotli4j</groupId>
+            <artifactId>brotli4j</artifactId>
+            <version>1.20.0</version>
+        </dependency>
 
     </dependencies>
     <build>

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

@@ -3,6 +3,7 @@
 import org.example.config.AppConfig;
 import org.example.config.ConfigLoader;
 
+import java.net.Socket;
 import java.nio.file.Path;
 
 public class App {
@@ -16,7 +17,7 @@ public static void main(String[] args) {
 
         int port = resolvePort(args, appConfig.server().port());
 
-        new TcpServer(port).start();
+        new TcpServer(port, ConnectionHandler::new).start();
     }
 
     static int resolvePort(String[] args, int configPort) {

src/main/java/org/example/ConnectionFactory.java

@@ -0,0 +1,7 @@
+package org.example;
+
+import java.net.Socket;
+
+public interface ConnectionFactory {
+    ConnectionHandler create(Socket socket);
+}

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

@@ -1,6 +1,15 @@
 package org.example;
 
+import org.example.config.AppConfig;
+import org.example.filter.IpFilter;
 import org.example.httpparser.HttpParser;
+import org.example.httpparser.HttpRequest;
+import java.util.ArrayList;
+import java.util.List;
+import org.example.filter.Filter;
+import org.example.filter.FilterChainImpl;
+import org.example.http.HttpResponseBuilder;
+import org.example.config.ConfigLoader;
 
 import java.io.IOException;
 import java.net.Socket;
@@ -9,34 +18,115 @@ public class ConnectionHandler implements AutoCloseable {
 
     Socket client;
     String uri;
+    private final List<Filter> filters;
+    String webRoot;
 
     public ConnectionHandler(Socket client) {
         this.client = client;
+        this.filters = buildFilters();
+        this.webRoot = null;
+    }
+
+    public ConnectionHandler(Socket client, String webRoot) {
+        this.client = client;
+        this.webRoot = webRoot;
+        this.filters = buildFilters();
+    }
+
+    private List<Filter> buildFilters() {
+        List<Filter> list = new ArrayList<>();
+        AppConfig config = ConfigLoader.get();
+        AppConfig.IpFilterConfig ipFilterConfig = config.ipFilter();
+        if (Boolean.TRUE.equals(ipFilterConfig.enabled())) {
+            list.add(createIpFilterFromConfig(ipFilterConfig));
+        }
+        // Add more filters here...
+        return list;
     }
 
     public void runConnectionHandler() throws IOException {
-        StaticFileHandler sfh = new StaticFileHandler();
+        StaticFileHandler sfh;
+
+        if (webRoot != null) {
+            sfh = new StaticFileHandler(webRoot);
+        } else {
+            sfh = new StaticFileHandler();
+        }
+
         HttpParser parser = new HttpParser();
         parser.setReader(client.getInputStream());
         parser.parseRequest();
         parser.parseHttp();
+
+        HttpRequest request = new HttpRequest(
+                parser.getMethod(),
+                parser.getUri(),
+                parser.getVersion(),
+                parser.getHeadersMap(),
+                ""
+        );
+
+        String clientIp = client.getInetAddress().getHostAddress();
+        request.setAttribute("clientIp", clientIp);
+
+        HttpResponseBuilder response = applyFilters(request);
+
+        int statusCode = response.getStatusCode();
+        if (statusCode == HttpResponseBuilder.SC_FORBIDDEN ||
+                statusCode == HttpResponseBuilder.SC_BAD_REQUEST) {
+            byte[] responseBytes = response.build();
+            client.getOutputStream().write(responseBytes);
+            client.getOutputStream().flush();
+            return;
+        }
+
         resolveTargetFile(parser.getUri());
         sfh.sendGetRequest(client.getOutputStream(), uri);
     }
 
+    private HttpResponseBuilder applyFilters(HttpRequest request) {
+        HttpResponseBuilder response = new HttpResponseBuilder();
+
+        FilterChainImpl chain = new FilterChainImpl(filters);
+        chain.doFilter(request, response);
+
+        return response;
+    }
+
     private void resolveTargetFile(String uri) {
-        if (uri.matches("/$")) { //matches(/)
+        if (uri == null || "/".equals(uri)) {
             this.uri = "index.html";
-        } else if (uri.matches("^(?!.*\\.html$).*$")) {
-            this.uri = uri.concat(".html");
         } else {
-            this.uri = uri;
+            this.uri = uri.startsWith("/") ? uri.substring(1) : uri;
         }
-
     }
 
     @Override
     public void close() throws Exception {
         client.close();
     }
-}
+
+    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);
+        }
+
+        filter.init();
+        return filter;
+    }
+}

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

@@ -1,15 +1,23 @@
 package org.example;
 
+import org.example.http.HttpResponseBuilder;
+
 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;
 
-    public TcpServer(int port) {
+    public TcpServer(int port, ConnectionFactory connectionFactory) {
         this.port = port;
+        this.connectionFactory = connectionFactory;
     }
 
     public void start() {
@@ -26,11 +34,42 @@ public void start() {
         }
     }
 
-    private void handleClient(Socket client) {
-        try (ConnectionHandler connectionHandler = new ConnectionHandler(client)) {
-            connectionHandler.runConnectionHandler();
+    protected void handleClient(Socket client) {
+        try(client){
+            processRequest(client);
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to close socket", e);
+        }
+    }
+
+    private void processRequest(Socket client) throws Exception {
+        ConnectionHandler handler = null;
+        try{
+            handler = connectionFactory.create(client);
+            handler.runConnectionHandler();
         } catch (Exception e) {
-            throw new RuntimeException("Error handling client connection " + 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.flush();
+            } catch (IOException e) {
+                System.err.println("Failed to send 500 response: " + e.getMessage());
+            }
         }
     }
 }

src/main/java/org/example/config/AppConfig.java

@@ -6,16 +6,22 @@
 @JsonIgnoreProperties(ignoreUnknown = true)
 public record AppConfig(
         @JsonProperty("server") ServerConfig server,
-        @JsonProperty("logging") LoggingConfig logging
+        @JsonProperty("logging") LoggingConfig logging,
+        @JsonProperty("ipFilter") IpFilterConfig ipFilter
 ) {
     public static AppConfig defaults() {
-        return new AppConfig(ServerConfig.defaults(), LoggingConfig.defaults());
+        return new AppConfig(
+                ServerConfig.defaults(),
+                LoggingConfig.defaults(),
+                IpFilterConfig.defaults()
+        );
     }
 
     public AppConfig withDefaultsApplied() {
         ServerConfig serverConfig = (server == null ? ServerConfig.defaults() : server.withDefaultsApplied());
         LoggingConfig loggingConfig = (logging == null ? LoggingConfig.defaults() : logging.withDefaultsApplied());
-        return new AppConfig(serverConfig, loggingConfig);
+        IpFilterConfig ipFilterConfig = (ipFilter == null ? IpFilterConfig.defaults() : ipFilter.withDefaultsApplied());  // ← LÄGG TILL
+        return new AppConfig(serverConfig, loggingConfig, ipFilterConfig);  // ← UPPDATERA DENNA RAD
     }
 
     @JsonIgnoreProperties(ignoreUnknown = true)
@@ -50,4 +56,24 @@ public LoggingConfig withDefaultsApplied() {
             return new LoggingConfig(lvl);
         }
     }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    public record IpFilterConfig(
+            @JsonProperty("enabled") Boolean enabled,
+            @JsonProperty("mode") String mode,
+            @JsonProperty("blockedIps") java.util.List<String> blockedIps,
+            @JsonProperty("allowedIps") java.util.List<String> allowedIps
+    ) {
+        public static IpFilterConfig defaults() {
+            return new IpFilterConfig(false, "BLOCKLIST", java.util.List.of(), java.util.List.of());
+        }
+
+        public IpFilterConfig withDefaultsApplied() {
+            Boolean e = (enabled == null) ? false : enabled;
+            String m = (mode == null || mode.isBlank()) ? "BLOCKLIST" : mode;
+            java.util.List<String> blocked = (blockedIps == null) ? java.util.List.of() : blockedIps;
+            java.util.List<String> allowed = (allowedIps == null) ? java.util.List.of() : allowedIps;
+            return new IpFilterConfig(e, m, blocked, allowed);
+        }
+    }
 }

src/main/java/org/example/config/ConfigLoader.java

@@ -65,7 +65,7 @@ private static ObjectMapper createMapperFor(Path configPath) {
         }
     }
 
-    static void resetForTests() {
+    public static void resetForTests() {
         cached = null;
     }
 }