Merge branch 'main' into feature/mime-type-detection

Author: gitnes94

pom.xml

@@ -54,6 +54,18 @@
             <version>4.3.0</version>
             <scope>test</scope>
         </dependency>
+
+        <dependency>
+            <groupId>tools.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>3.0.3</version>
+        </dependency>
+        <dependency>
+            <groupId>tools.jackson.dataformat</groupId>
+            <artifactId>jackson-dataformat-yaml</artifactId>
+            <version>3.0.3</version>
+        </dependency>
+
     </dependencies>
     <build>
         <plugins>

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

@@ -0,0 +1,42 @@
+package org.example;
+
+import org.example.httpparser.HttpParser;
+
+import java.io.IOException;
+import java.net.Socket;
+
+public class ConnectionHandler implements AutoCloseable {
+
+    Socket client;
+    String uri;
+
+    public ConnectionHandler(Socket client) {
+        this.client = client;
+    }
+
+    public void runConnectionHandler() throws IOException {
+        StaticFileHandler sfh = new StaticFileHandler();
+        HttpParser parser = new HttpParser();
+        parser.setReader(client.getInputStream());
+        parser.parseRequest();
+        parser.parseHttp();
+        resolveTargetFile(parser.getUri());
+        sfh.sendGetRequest(client.getOutputStream(), uri);
+    }
+
+    private void resolveTargetFile(String uri) {
+        if (uri.matches("/$")) { //matches(/)
+            this.uri = "index.html";
+        } else if (uri.matches("^(?!.*\\.html$).*$")) {
+            this.uri = uri.concat(".html");
+        } else {
+            this.uri = uri;
+        }
+
+    }
+
+    @Override
+    public void close() throws Exception {
+        client.close();
+    }
+}

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

@@ -0,0 +1,56 @@
+package org.example;
+
+import org.example.http.HttpResponseBuilder;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.util.Map;
+
+public class StaticFileHandler {
+    private final String WEB_ROOT;
+    private byte[] fileBytes;
+    private int statusCode;
+
+    //Constructor for production
+    public StaticFileHandler() {
+        WEB_ROOT = "www";
+    }
+
+    //Constructor for tests, otherwise the www folder won't be seen
+    public StaticFileHandler(String webRoot){
+        WEB_ROOT = webRoot;
+    }
+
+    private void handleGetRequest(String uri) throws IOException {
+
+        File file = new File(WEB_ROOT, uri);
+        if(file.exists()) {
+            fileBytes = Files.readAllBytes(file.toPath());
+            statusCode = 200;
+        } else {
+            File errorFile = new File(WEB_ROOT, "pageNotFound.html");
+            if(errorFile.exists()) {
+                fileBytes = Files.readAllBytes(errorFile.toPath());
+            } else {
+                fileBytes = "404 Not Found".getBytes();
+            }
+            statusCode = 404;
+        }
+    }
+
+    public void sendGetRequest(OutputStream outputStream, String uri) throws IOException{
+        handleGetRequest(uri);
+
+        HttpResponseBuilder response = new HttpResponseBuilder();
+        response.setStatusCode(statusCode);
+        response.setHeaders(Map.of("Content-Type", "text/html; charset=utf-8"));
+        response.setBody(fileBytes);
+        PrintWriter writer = new PrintWriter(outputStream, true);
+        writer.println(response.build());
+
+    }
+
+}

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

@@ -19,10 +19,18 @@ public void start() {
             while (true) {
                 Socket clientSocket = serverSocket.accept(); // block
                 System.out.println("Client connected: " + clientSocket.getRemoteSocketAddress());
-                clientSocket.close();
+                Thread.ofVirtual().start(() -> handleClient(clientSocket));
             }
         } catch (IOException e) {
             throw new RuntimeException("Failed to start TCP server", e);
         }
     }
-}
+
+    private void handleClient(Socket client) {
+        try (ConnectionHandler connectionHandler = new ConnectionHandler(client)) {
+            connectionHandler.runConnectionHandler();
+        } catch (Exception e) {
+            throw new RuntimeException("Error handling client connection " + e);
+        }
+    }
+}

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

@@ -0,0 +1,53 @@
+package org.example.config;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+public record AppConfig(
+        @JsonProperty("server") ServerConfig server,
+        @JsonProperty("logging") LoggingConfig logging
+) {
+    public static AppConfig defaults() {
+        return new AppConfig(ServerConfig.defaults(), LoggingConfig.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);
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    public record ServerConfig(
+            @JsonProperty("port") Integer port,
+            @JsonProperty("rootDir") String rootDir
+    ) {
+        public static ServerConfig defaults() {
+            return new ServerConfig(8080, "./www");
+        }
+
+        public ServerConfig withDefaultsApplied() {
+            int p = (port == null ? 8080 : port);
+            if (p < 1 || p > 65535) {
+                throw new IllegalArgumentException("Invalid port number: " + p + ". Port must be between 1 and 65535");
+            }
+            String rd = (rootDir == null || rootDir.isBlank()) ? "./www" : rootDir;
+            return new ServerConfig(p, rd);
+        }
+    }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    public record LoggingConfig(
+            @JsonProperty("level") String level
+    ) {
+        public static LoggingConfig defaults() {
+            return new LoggingConfig("INFO");
+        }
+
+        public LoggingConfig withDefaultsApplied() {
+            String lvl = (level == null || level.isBlank()) ? "INFO" : level;
+            return new LoggingConfig(lvl);
+        }
+    }
+}

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

@@ -0,0 +1,71 @@
+package org.example.config;
+
+import tools.jackson.databind.ObjectMapper;
+import tools.jackson.databind.json.JsonMapper;
+import tools.jackson.dataformat.yaml.YAMLFactory;
+import tools.jackson.dataformat.yaml.YAMLMapper;
+
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Objects;
+
+public final class ConfigLoader {
+
+    private static volatile AppConfig cached;
+
+    private ConfigLoader() {}
+
+    public static AppConfig loadOnce(Path configPath) {
+        if (cached != null) return cached;
+
+        synchronized (ConfigLoader.class) {
+            if (cached == null){
+                cached = load(configPath).withDefaultsApplied();
+            }
+            return cached;
+        }
+    }
+
+    public static AppConfig get(){
+        if (cached == null){
+            throw new IllegalStateException("Config not loaded. call ConfigLoader.loadOnce(...) at startup.");
+        }
+        return cached;
+
+    }
+
+    public static AppConfig load(Path configPath) {
+        Objects.requireNonNull(configPath, "configPath");
+
+        if (!Files.exists(configPath)) {
+            return AppConfig.defaults();
+        }
+
+        ObjectMapper objectMapper = createMapperFor(configPath);
+
+        try (InputStream stream = Files.newInputStream(configPath)){
+            AppConfig config = objectMapper.readValue(stream, AppConfig.class);
+            return config == null ? AppConfig.defaults() : config;
+        } catch (Exception e){
+            throw new IllegalStateException("failed to read config file " + configPath.toAbsolutePath(), e);
+        }
+    }
+
+    private static ObjectMapper createMapperFor(Path configPath) {
+        String name = configPath.getFileName().toString().toLowerCase();
+
+        if (name.endsWith(".yml") || name.endsWith(".yaml")) {
+            return YAMLMapper.builder(new YAMLFactory()).build();
+
+        } else if (name.endsWith(".json")) {
+            return JsonMapper.builder().build();
+        } else  {
+            return YAMLMapper.builder(new YAMLFactory()).build();
+        }
+    }
+
+    static void resetForTests() {
+        cached = null;
+    }
+}

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

@@ -36,7 +36,6 @@ public class HttpResponseBuilder {
     public void setStatusCode(int statusCode) {
         this.statusCode = statusCode;
     }
-
     public void setBody(String body) {
         this.body = body != null ? body : "";
         this.bytebody = null; // Clear byte body when setting string body

src/main/java/org/example/httpparser/HttpParser.java

@@ -13,7 +13,7 @@ public class HttpParser extends HttpParseRequestLine {
     private Map<String, String> headersMap = new HashMap<>();
     private BufferedReader reader;
 
-    protected void setReader(InputStream in) {
+    public void setReader(InputStream in) {
         if (this.reader == null) {
             this.reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8));
         }

src/main/resources/application.yml

@@ -0,0 +1,6 @@
+server:
+  port: 8080
+  rootDir: ./www
+
+logging:
+  level: INFO

src/test/java/org/example/StaticFileHandlerTest.java

@@ -0,0 +1,79 @@
+package org.example;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Unit test class for verifying the behavior of the StaticFileHandler class.
+ *
+ * This test class ensures that StaticFileHandler correctly handles GET requests
+ * for static files, including both cases where the requested file exists and
+ * where it does not. Temporary directories and files are utilized in tests to
+ * ensure no actual file system dependencies during test execution.
+ *
+ * Key functional aspects being tested include:
+ * - Correct response status code and content for an existing file.
+ * - Correct response status code and fallback behavior for a missing file.
+ */
+class StaticFileHandlerTest {
+
+    //Junit creates a temporary folder which can be filled with temporary files that gets removed after tests
+    @TempDir
+    Path tempDir;
+
+
+    @Test
+    void test_file_that_exists_should_return_200() throws IOException {
+        //Arrange
+        Path testFile = tempDir.resolve("test.html"); // Defines the path in the temp directory
+        Files.writeString(testFile, "Hello Test"); // Creates a text in that file
+
+        //Using the new constructor in StaticFileHandler to reroute so the tests uses the temporary folder instead of the hardcoded www
+        StaticFileHandler staticFileHandler = new StaticFileHandler(tempDir.toString());
+
+        //Using ByteArrayOutputStream instead of Outputstream during tests to capture the servers response in memory, fake stream
+        ByteArrayOutputStream fakeOutput = new ByteArrayOutputStream();
+
+        //Act
+        staticFileHandler.sendGetRequest(fakeOutput, "test.html"); //Get test.html and write the answer to fakeOutput
+
+        //Assert
+        String response = fakeOutput.toString();//Converts the captured byte stream into a String for verification
+
+        assertTrue(response.contains("HTTP/1.1 200 OK")); // Assert the status
+        assertTrue(response.contains("Hello Test")); //Assert the content in the file
+
+        assertTrue(response.contains("Content-Type: text/html; charset=utf-8")); // Verify the correct Content-type header
+
+    }
+
+    @Test
+    void test_file_that_does_not_exists_should_return_404() throws IOException {
+        //Arrange
+        // Pre-create the mandatory error page in the temp directory to prevent NoSuchFileException
+        Path testFile = tempDir.resolve("pageNotFound.html");
+        Files.writeString(testFile, "Fallback page");
+
+        //Using the new constructor in StaticFileHandler to reroute so the tests uses the temporary folder instead of the hardcoded www
+        StaticFileHandler staticFileHandler = new StaticFileHandler(tempDir.toString());
+
+        //Using ByteArrayOutputStream instead of Outputstream during tests to capture the servers response in memory, fake stream
+        ByteArrayOutputStream fakeOutput = new ByteArrayOutputStream();
+
+        //Act
+        staticFileHandler.sendGetRequest(fakeOutput, "notExistingFile.html"); // Request a file that clearly doesn't exist to trigger the 404 logic
+
+        //Assert
+        String response = fakeOutput.toString();//Converts the captured byte stream into a String for verification
+
+        assertTrue(response.contains("HTTP/1.1 404 Not Found")); // Assert the status
+
+    }
+
+}