[HttpServer series] Static File server, and Logging
Tags: java, learning, frameworks
Published: 2024-01-29 02:31:45

---
title: [HttpServer series] Static File server, and Logging
published: true
date: 2024-01-28 22:22:50 UTC
tags: java, learning, frameworks 
series: Project No-Web-Framework-No-Annotations using Java
canonical_url: https://blog.mandraketech.in/httpserver-series-static-file-server-and-logging
---

As we delve deeper into the series, today we attempt to write a Static file server, and wire it up to serve css and html pages.

As with the other posts, you can see the [merge request](https://gitlab.com/mandraketech/httpserver-based-todo-app/-/merge_requests/9) for the code change, the [repository for the entire code](https://gitlab.com/mandraketech/httpserver-based-todo-app) or the [series for all the articles](https://blog.mandraketech.in/series/java-http-server) on the journey.

The first thing that needed to be done is write a handler for static files. Here is the structure of the `StaticFileHandler`:

```
public RouteResponse handle(RouteRequest req) { // only support get calls if (req.method() != RequestMethod.GET) { // 404: Not Found is automatically handled return null; } String uriPath = computeUriPath(req.uri().getPath()); // never allow access to any directory var path = Paths.get(this.folder, uriPath); // if the file doesn't exist, or is a directory, return null if (!Files.isRegularFile(path)) { // 404: Not Found is automatically handled return null; } // get content mime time based on file name try { var contentType = Files.probeContentType(path); if (contentType == null) { throw new IllegalArgumentException("Unable to determine content type for file: " + path); } // read the file and return in the response var fileContent = new String(Files.readAllBytes(path)); return new RouteResponse(200, contentType, fileContent); } catch (IOException e) { LoggerConfig.getApplicationLogger().log(Level.SEVERE, "Error while accessing file: {0} ", path); LoggerConfig.getApplicationLogger().log(Level.SEVERE, "Error Message: {0} ", e.getLocalizedMessage()); LoggerConfig.getApplicationLogger().log(Level.SEVERE, "Error Trace: {0} ", e.getStackTrace()); return new RouteResponse(403, ContentType.CONTENT_TYPE_TEXT.getValue(), "Forbidden"); } }
```

The notable pieces here are:

- the handling of only the `GET` verb

- handling of file existence, and only a file, not a directory

- setting the content type of the response, based on the file name

- returning a 403 / Forbidden, when there is an exception accessing the file

The `Router`'s `sendResponse` now handles more cases, ensuring a proper cleanup, and a content type, if there is a body specified in the response:

```
 private void sendResponse(HttpExchange exchange, RouteResponse response) throws IOException { if (response.body() != null && !HeaderHelper.hasContentType(response.headers())) { throw new IllegalArgumentException("Need a content type if response body is specified"); } try (var os = exchange.getResponseBody()) { int respBodyLen = response.body() == null ? -1 : response.body().getBytes().length; exchange.sendResponseHeaders(response.statusCode(), respBodyLen); var responseHeaders = exchange.getResponseHeaders(); // add the headers from the response to the exchange responseHeaders.putAll(response.headers()); if (respBodyLen >= 0) { os.write(response.body().getBytes()); } } }
```

The tests have been updated. This time to handle the missing condition of "Internal server exception", in the `RouterTest`.

```
    @Test void testInternalServerError() { var req = RouterHelper.createGetRequest("/error"); var resp = router.processRequest(req); assertEquals(500, resp.statusCode()); assertEquals(List.of("text/plain"), resp.headers().get("Content-Type")); }
```

The route for handling `/error` in the test is just a simple:

```
config.addHandler("/error", (req) -> { throw new RuntimeException("Exception for testing."); });
```

The logging usage is slightly unconventional. But first, the setup code:

```
static void setupGlobalConsoleLogger() { // Get the global logger Logger globalLogger = Logger.getLogger(""); // always log info and above for all loggers globalLogger.setLevel(Level.INFO); // Remove any existing handlers to avoid duplication Handler[] handlers = globalLogger.getHandlers(); for (Handler handler : handlers) { globalLogger.removeHandler(handler); } // Create a console handler and set its log level var consoleHandler = new ConsoleHandler(); consoleHandler.setFilter(f -> true); consoleHandler.setFormatter(new Formatter() { final SimpleDateFormat loggerDateFormat = new SimpleDateFormat("dd/MMM/yy HH:mm:ss.SSS"); public String format(LogRecord lr) { var message = lr.getMessage(); var params = lr.getParameters(); if (params != null && params.length > 0) { message = MessageFormat.format(message, params); } String formattedDate = loggerDateFormat.format(Date.from(lr.getInstant())); return String.format("%d::%s::%s::%s::%s::%s%n", lr.getLongThreadID(), lr.getLoggerName(), lr.getSourceClassName(), lr.getSourceMethodName(), formattedDate, message); } }); // Add the console handler to the global logger globalLogger.addHandler(consoleHandler); // setup the specific app loggers after the global settings if (RuntimeConfig.getInstance().runMode() == RuntimeConfig.RunMode.PROD) { // only log sever message from the debug logs, in prod getDebugLogger().setLevel(Level.SEVERE); } else { getDebugLogger().setLevel(Level.FINE); } }
```

When I asked the question: `What is the logger caching strategy for java.util.logging framework ? When do the created loggers release memory ?` to ChatGPT, the response I got was:

`The Logger instances are typically stored using weak references. This means that if there are no strong references to a logger (i.e., it's not actively used), it may be eligible for garbage collection. Weak references allow unused loggers to be automatically released when memory is needed.`

This essentially means that I have been doing loggers wrong all this while, but just creating and keeping references at the instance level.

Also, when I looked at the `Formatter` available for the `ConsoleHandler` above, I could log the class and method name of the caller. So, there was no need to create loggers that are specific to each class. Instead, I decided on using two kinds of loggers, an Application level logger, and a Debug logger. The idea behind these is to have explicit intent. Anything that goes into the "Application Logger" is intended to always be logged. While the "Debug logger" should be turned on only for debug purposes, unless the debug message is a "SEVERE" in which case it should always be logged. This allows better memory utilisation, and ensures that the printing format is under control.

There is an explicit intent to use only the ConsoleHandler, and no file handler, because I assume that the application will always be deployed with a Container manager like Docker, or a process manager that will redirect the standard console and error streams to its respective handling mechanism.

With this implementation, the server is "functional". It can serve static content, from a specified directory, and also handle requests received over the http flow. It handles the 404, and 500 errors, and cleans up the streams on its way out. So, the client will not be waiting for a response.

Next step will be to explore an authorisation