Implement configurable filter pipeline (global + per‑route filters)

.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: Java CI with Maven
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Get Java Version
+        run: |
+          JAVA_VERSION=$(mvn help:evaluate "-Dexpression=maven.compiler.release" -q -DforceStdout)
+          echo "JAVA_VERSION=$JAVA_VERSION" >> $GITHUB_ENV
+
+      - name: Set up JDK ${{ env.JAVA_VERSION }}
+        uses: actions/setup-java@v4
+        with:
+          java-version: ${{ env.JAVA_VERSION }}
+          distribution: 'temurin'
+          cache: maven
+
+      - name: Compile with Maven
+        run: mvn -B compile --file pom.xml
+
+      - name: Test with Maven
+        run: mvn -B test --file pom.xml

.github/workflows/release.yml

@@ -0,0 +1,35 @@
+name: Publish Docker Image to Github Packages on Release
+on:
+  release:
+    types:
+      - published
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - uses: actions/checkout@v6.0.2
+      - uses: docker/setup-qemu-action@v3.7.0
+      - uses: docker/setup-buildx-action@v3.12.0
+      - name: Log in to GHCR
+        uses: docker/login-action@v3.7.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5.10.0
+        with:
+          images: ghcr.io/ithsjava25/webserver
+      - name: Build and push
+        uses: docker/build-push-action@v6.18.0
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64, linux/arm64
+          tags:  ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+

pom.xml

@@ -9,12 +9,13 @@
     <version>1.0-SNAPSHOT</version>
 
     <properties>
-        <maven.compiler.release>23</maven.compiler.release>
+        <maven.compiler.release>25</maven.compiler.release>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <junit.jupiter.version>6.0.2</junit.jupiter.version>
         <assertj.core.version>3.27.7</assertj.core.version>
         <mockito.version>5.21.0</mockito.version>
     </properties>
+
     <dependencies>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -28,12 +29,24 @@
             <version>${assertj.core.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>${mockito.version}</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-junit-jupiter</artifactId>
             <version>${mockito.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <version>4.3.0</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
     <build>
         <plugins>
@@ -118,6 +131,39 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>org.pitest</groupId>
+                <artifactId>pitest-maven</artifactId>
+                <version>1.22.0</version>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.pitest</groupId>
+                        <artifactId>pitest-junit5-plugin</artifactId>
+                        <version>1.2.2</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
+            <plugin>
+                <groupId>com.diffplug.spotless</groupId>
+                <artifactId>spotless-maven-plugin</artifactId>
+                <version>3.2.1</version>
+                <configuration>
+                    <java>
+                        <removeUnusedImports/>
+                        <formatAnnotations/>
+                    </java>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>verify</phase>
+                        <goals>
+                            <goal>
+                                check
+                            </goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 </project>

src/main/java/org/example/server/ConfigurableFilterPipeline.java

@@ -0,0 +1,146 @@
+package org.example.server;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class ConfigurableFilterPipeline {
+
+    private final List<FilterRegistration> registrations;
+
+    public ConfigurableFilterPipeline(List<FilterRegistration> registrations) {
+        this.registrations = registrations;
+    }
+
+    public HttpResponse execute(HttpRequest request, TerminalHandler handler) {
+
+        List<HttpFilter> globalFilters = new ArrayList<>();
+        List<HttpFilter> routeFilters = new ArrayList<>();
+
+        for (FilterRegistration reg : registrations) {
+
+            if (reg.isGlobal()) {
+                globalFilters.add(reg.filter());
+            } else {
+                if (matchesAny(reg.routePatterns(), request.path())) {
+                    routeFilters.add(reg.filter());
+                }
+            }
+        }
+
+        Collections.sort(globalFilters, new Comparator<HttpFilter>() {
+            @Override
+            public int compare(HttpFilter f1, HttpFilter f2) {
+                return Integer.compare(getOrder(f1), getOrder(f2));
+            }
+        });
+
+        Collections.sort(routeFilters, new Comparator<HttpFilter>() {
+            @Override
+            public int compare(HttpFilter f1, HttpFilter f2) {
+                return Integer.compare(getOrder(f1), getOrder(f2));
+            }
+        });
+
+        List<HttpFilter> allFilters = new ArrayList<>();
+        allFilters.addAll(globalFilters);
+        allFilters.addAll(routeFilters);
+
+        return buildChain(allFilters, handler).next(request);
+    }
+
+    private boolean matchesAny(List<String> patterns, String path) {
+        if (patterns == null) return false;
+
+        for (String pattern : patterns) {
+            if (RoutePattern.matches(pattern, path)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private FilterChain buildChain(List<HttpFilter> filters, TerminalHandler handler) {
+
+        FilterChain chain = new FilterChain() {
+            @Override
+            public HttpResponse next(HttpRequest request) {
+                return handler.handle(request);
+            }
+        };
+
+        for (int i = filters.size() - 1; i >= 0; i--) {
+
+            HttpFilter currentFilter = filters.get(i);
+            FilterChain nextChain = chain;
+
+            chain = new FilterChain() {
+                @Override
+                public HttpResponse next(HttpRequest request) {
+                    return currentFilter.handle(request, nextChain);
+                }
+            };
+        }
+
+        return chain;
+    }
+
+    private int getOrder(HttpFilter filter) {
+        for (FilterRegistration reg : registrations) {
+            if (reg.filter() == filter) {
+                return reg.order();
+            }
+        }
+        return 0;
+    }
+}
+
+class HttpRequest {
+    private final String method;
+    private final String path;
+
+    public HttpRequest(String method, String path) {
+        this.method = method;
+        this.path = path;
+    }
+
+    public String path() {
+        return path;
+    }
+
+    public String getMethod() {
+        return method;
+    }
+}
+
+class HttpResponse {
+    private final int statusCode;
+    private final String body;
+
+    public HttpResponse(int statusCode, String body) {
+        this.statusCode = statusCode;
+        this.body = body;
+    }
+
+    public int getStatusCode() {
+        return statusCode;
+    }
+
+    public String getBody() {
+        return body;
+    }
+}
+
+interface HttpFilter {
+    HttpResponse handle(HttpRequest request, FilterChain chain);
+}
+
+interface FilterChain {
+    HttpResponse next(HttpRequest request);
+}
+
+interface TerminalHandler {
+    HttpResponse handle(HttpRequest request);
+}

src/main/java/org/example/server/FilterRegistration.java

@@ -0,0 +1,14 @@
+package org.example.server;
+
+import java.util.List;
+
+public record FilterRegistration(
+        HttpFilter filter,
+        int order,
+        List<String> routePatterns
+) {
+
+    public boolean isGlobal() {
+        return routePatterns == null || routePatterns.isEmpty();
+    }
+}

src/main/java/org/example/server/RoutePattern.java

@@ -0,0 +1,17 @@
+package org.example.server;
+
+public final class RoutePattern {
+
+    private RoutePattern() {}
+
+    public static boolean matches(String pattern, String path) {
+        if (pattern == null || path == null) return false;
+
+        if (pattern.endsWith("/*")) {
+            String prefix = pattern.substring(0, pattern.length() - 1);
+            return path.startsWith(prefix);
+        }
+
+        return pattern.equals(path);
+    }
+}