Add cookie-session middleware

Author: simonwep

src/express/Express.java

@@ -1,16 +1,19 @@
 package express;
 
-import com.sun.net.httpserver.HttpContext;
 import com.sun.net.httpserver.HttpServer;
 import express.events.Action;
 import express.events.HttpRequest;
 import express.expressfilter.ExpressFilter;
 import express.expressfilter.ExpressFilterChain;
 import express.http.Request;
 import express.http.Response;
+import express.middleware.ExpressWorker;
 
 import java.io.IOException;
 import java.net.InetSocketAddress;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 
 /**
  * @author Simon Reinisch
@@ -20,6 +23,7 @@
  */
 public class Express {
 
+  private final List<ExpressWorker> WORKERS = Collections.synchronizedList(new ArrayList<>());
   private final ExpressFilterChain FILTER_CHAIN = new ExpressFilterChain();
 
   private HttpServer httpServer;
@@ -125,6 +129,12 @@ public void patch(String context, HttpRequest request) {
   private void addFilter(boolean middleware, String requestMethod, String context, HttpRequest request) {
     ExpressFilter handler = new ExpressFilter(requestMethod, context, request);
 
+    if (request instanceof ExpressWorker){
+      ((ExpressWorker) request).start();
+      WORKERS.add((ExpressWorker) request);
+    }
+
+
     // Middleware needs an seperated list because it will ALWAYS fired before each request handler
     if (middleware)
       FILTER_CHAIN.addMiddleware(handler);
@@ -138,6 +148,7 @@ private void addFilter(boolean middleware, String requestMethod, String context,
    *
    * @throws IOException - If an IO-Error occurs, eg. the port is already in use.
    */
+
   public void listen() throws IOException {
     listen(null, 80);
   }

src/express/http/Request.java

@@ -3,6 +3,7 @@
 import com.sun.net.httpserver.Headers;
 import com.sun.net.httpserver.HttpExchange;
 import express.http.cookie.Cookie;
+import express.middleware.ExpressMiddleware;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -27,6 +28,8 @@ public class Request {
   private final Headers HEADER;
   private final String CONTENT_TYPE;
 
+  private final HashMap<String, Object> MIDDLEWARE;
+
   private final HashMap<String, Cookie> COOKIES;
   private final HashMap<String, String> QUERYS;
   private HashMap<String, String> params;
@@ -38,6 +41,7 @@ public Request(HttpExchange exchange) {
     this.BODY = exchange.getRequestBody();
     this.CONTENT_TYPE = HEADER.get("Content-Type") == null ? "" : HEADER.get("Content-Type").get(0);
 
+    this.MIDDLEWARE = new HashMap<>();
     this.params = new HashMap<>();
 
     this.QUERYS = parseRawQuery(exchange.getRequestURI());
@@ -85,6 +89,14 @@ public HashMap<String, Cookie> getCookies() {
     return COOKIES;
   }
 
+  public void addMiddlewareContent(ExpressMiddleware middleware, Object middlewareData) {
+    MIDDLEWARE.put(middleware.getName(), middlewareData);
+  }
+
+  public Object getMiddlewareContent(String name) {
+    return MIDDLEWARE.get(name);
+  }
+
   /**
    * @return The request user-agent.
    */

src/express/middleware/CookieSession.java

@@ -0,0 +1,72 @@
+package express.middleware;
+
+import express.events.HttpRequest;
+import express.http.Request;
+import express.http.Response;
+import express.http.cookie.Cookie;
+
+import java.math.BigInteger;
+import java.security.SecureRandom;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class CookieSession extends ExpressWorker implements HttpRequest, ExpressMiddleware {
+
+  private final static String MIDDLEWARE_NAME = "SessionCookie";
+
+  private final ConcurrentHashMap<String, SessionCookie> COOKIES = new ConcurrentHashMap<>();
+  private final String COOKIE_NAME;
+  private final long MAX_AGE;
+
+  public CookieSession(String cookieName, long maxAge) {
+    this.COOKIE_NAME = cookieName;
+    this.MAX_AGE = maxAge;
+  }
+
+  @Override
+  public String getName() {
+    return MIDDLEWARE_NAME;
+  }
+
+  @Override
+  public void handle(Request req, Response res) {
+    Cookie cookie = req.getCookie(COOKIE_NAME);
+
+    if (cookie != null && COOKIES.containsKey(cookie.getValue())) {
+
+      req.addMiddlewareContent(this, COOKIES.get(cookie.getValue()));
+    } else {
+      String token = generateSecureToken(32);
+
+      cookie = new Cookie(COOKIE_NAME, token).setMaxAge(MAX_AGE);
+      res.setCookie(cookie);
+
+      SessionCookie sessionCookie = new SessionCookie(MAX_AGE);
+      COOKIES.put(token, sessionCookie);
+
+      req.addMiddlewareContent(this, sessionCookie);
+    }
+  }
+
+  @Override
+  long getDelay() {
+    return 15000; // 1min
+  }
+
+  @Override
+  void update() {
+    long current = System.currentTimeMillis();
+
+    COOKIES.forEach((s, o) -> {
+      if (current > o.getCreated() + o.getMaxAge())
+        COOKIES.remove(s);
+    });
+  }
+
+  private static String generateSecureToken(int byteLength) {
+    SecureRandom secureRandom = new SecureRandom();
+    byte[] token = new byte[byteLength];
+    secureRandom.nextBytes(token);
+    return new BigInteger(1, token).toString(16); //hex encoding
+  }
+
+}

src/express/middleware/ExpressMiddleware.java

@@ -0,0 +1,5 @@
+package express.middleware;
+
+public interface ExpressMiddleware {
+  String getName();
+}

src/express/middleware/ExpressWorker.java

@@ -0,0 +1,23 @@
+package express.middleware;
+
+
+import express.utils.ExtendetTimer;
+
+public abstract class ExpressWorker {
+
+  private final ExtendetTimer TIMER = new ExtendetTimer();
+
+  public void start() {
+    if (!TIMER.isActive()) {
+      TIMER.scheduleAtFixedRate(this::update, 0, getDelay());
+    }
+  }
+
+  public void stop() {
+    TIMER.cancel();
+  }
+
+  abstract long getDelay();
+
+  abstract void update();
+}

src/express/middleware/SessionCookie.java

@@ -0,0 +1,31 @@
+package express.middleware;
+
+public class SessionCookie {
+
+  private final long MAX_AGE;
+  private final long CREATED;
+
+  private Object data;
+
+  public SessionCookie(long maxAge) {
+    this.MAX_AGE = maxAge;
+    this.CREATED = System.currentTimeMillis();
+  }
+
+  public long getMaxAge() {
+    return MAX_AGE;
+  }
+
+  public long getCreated() {
+    return CREATED;
+  }
+
+  public Object getData() {
+    return data;
+  }
+
+  public Object setData(Object data) {
+   return this.data = data;
+  }
+
+}

src/express/utils/ExtendetTimer.java

@@ -0,0 +1,70 @@
+package express.utils;
+
+import java.util.Date;
+import java.util.Timer;
+import java.util.TimerTask;
+
+public class ExtendetTimer extends Timer {
+
+  private ExtendetTimerTask extendetTimerTask;
+  private LambdaTimerTask lambdaTimerTask;
+  private boolean isActive;
+
+  public void schedule(LambdaTimerTask task, long delay) {
+    init(task);
+    super.schedule(extendetTimerTask, delay);
+  }
+
+  public void schedule(LambdaTimerTask task, Date time) {
+    init(task);
+    super.schedule(extendetTimerTask, time);
+  }
+
+  public void schedule(LambdaTimerTask task, long delay, long period) {
+    init(task);
+    super.schedule(extendetTimerTask, delay, period);
+  }
+
+  public void schedule(LambdaTimerTask task, Date firstTime, long period) {
+    init(task);
+    super.schedule(extendetTimerTask, firstTime, period);
+  }
+
+  public void scheduleAtFixedRate(LambdaTimerTask task, long delay, long period) {
+    init(task);
+    super.scheduleAtFixedRate(extendetTimerTask, delay, period);
+  }
+
+  public void scheduleAtFixedRate(LambdaTimerTask task, Date firstTime, long period) {
+    init(task);
+    super.scheduleAtFixedRate(extendetTimerTask, firstTime, period);
+  }
+
+  private void init(LambdaTimerTask task){
+    extendetTimerTask = new ExtendetTimerTask();
+    isActive = true;
+    this.lambdaTimerTask = task;
+  }
+
+  public void cancel() {
+    isActive = false;
+    super.cancel();
+  }
+
+  public boolean isActive() {
+    return isActive;
+  }
+
+  private class ExtendetTimerTask extends TimerTask {
+    @Override
+    public void run() {
+      lambdaTimerTask.run();
+    }
+  }
+
+  @FunctionalInterface
+  public interface LambdaTimerTask {
+    void run();
+  }
+
+}

src/test/Use.java

@@ -1,7 +1,10 @@
 package test;
 
 import express.Express;
+import express.middleware.CookieSession;
+import express.middleware.SessionCookie;
 import express.middleware.Static;
+
 import java.io.IOException;
 
 public class Use {
@@ -12,6 +15,45 @@ public static void main(String[] args) throws IOException {
     // Test for static file service
     app.use(new Static("examplepath\\test_statics"));
 
+    // Test for cookie session
+    app.use(new CookieSession("ses", 9000));
+
+    // Cookie session example
+    app.get("/session", (req, res) -> {
+
+      /**
+       * Get the middleware object
+       * Every middleware who extend the request is saved in an hashmap
+       * with the name as key, so every middleware need to implement this interface
+       * to extend the request.
+       *
+       * You can access your middlewares data over getMiddlewareContent("MIDDLEWARE NAME")
+       */
+      Object middlewareObject = req.getMiddlewareContent("SessionCookie");
+
+      // Check if the middleware has set some data
+      if (middlewareObject != null) {
+
+        // Okay, now cast the object to an session cookie
+        SessionCookie sessionCookie = (SessionCookie) middlewareObject;
+        int count;
+
+        // Check if the data is null, we want to implement an simple counter
+        if (sessionCookie.getData() == null) {
+          // Set the default data to 1 (first request with this session cookie)
+          count = (Integer) sessionCookie.setData(1);
+        } else {
+          // Now we know that the cookie has an integer as data property, increase this
+          count = (Integer) sessionCookie.setData((Integer) sessionCookie.getData() + 1);
+        }
+
+        // Send an happy message :D
+        res.send("You take use of your session cookie " + count + " times :)");
+      } else {
+        res.send("No session cookie middleware used.");
+      }
+    });
+
 
     app.listen(() -> System.out.println("Express is listening!"));
   }