fix: Fix server session (#2913)

* fix server session

* fix version

double-buffer/README.md

@@ -3,36 +3,29 @@ title: Double Buffer
 category: Behavioral
 language: en
 tag:
- - Performance
+    - Buffering
     - Game programming
+    - Optimization
+    - Performance
 ---
 
 ## Intent
-Double buffering is a term used to describe a device that has two buffers. The usage of multiple 
+
-buffers increases the overall throughput of a device and helps prevents bottlenecks. This example 
+The Double Buffer pattern aims to reduce the time necessary for rendering and displaying graphical or computational data by utilizing two buffers. One buffer is used for rendering the next frame or computing the next set of data, while the other is used to display the current frame or data set to the user.
-shows using double buffer pattern on graphics. It is used to show one image or frame while a separate 
-frame is being buffered to be shown next. This method makes animations and games look more realistic 
-than the same done in a single buffer mode.   
 
 ## Explanation
 
 Real world example
-> A typical example, and one that every game engine must address, is rendering. When the game draws 
+
-> the world the users see, it does so one piece at a time -- the mountains in the distance, 
+> A typical example, and one that every game engine must address, is rendering. When the game draws the world the users see, it does so one piece at a time -- the mountains in the distance, the rolling hills, the trees, each in its turn. If the user watched the view draw incrementally like that, the illusion of a coherent world would be shattered. The scene must update smoothly and quickly, displaying a series of complete frames, each appearing instantly. Double buffering solves the problem.
-> the rolling hills, the trees, each in its turn. If the user watched the view draw incrementally 
-> like that, the illusion of a coherent world would be shattered. The scene must update smoothly 
-> and quickly, displaying a series of complete frames, each appearing instantly. Double buffering solves
-> the problem.
 
 In plain words
-> It ensures a state that is being rendered correctly while that state is modifying incrementally. It is
+
-> widely used in computer graphics.
+> It ensures a state that is being rendered correctly while that state is modifying incrementally. It is widely used in computer graphics.
 
 Wikipedia says
-> In computer science, multiple buffering is the use of more than one buffer to hold a block of data, 
+
-> so that a "reader" will see a complete (though perhaps old) version of the data, rather than a 
+> In computer science, multiple buffering is the use of more than one buffer to hold a block of data, so that a "reader" will see a complete (though perhaps old) version of the data, rather than a partially updated version of the data being created by a "writer". It is very commonly used for computer display images.
-> partially updated version of the data being created by a "writer". It is very commonly used for 
-> computer display images.
 
 **Programmatic Example**
 
@@ -76,6 +69,7 @@ public interface Buffer {
 ```
 
 One of the implementation of Buffer interface.
+
 ```java
 /**
  * FrameBuffer implementation class.
@@ -127,7 +121,9 @@ public enum Pixel {
     BLACK;
 }
 ```
+
 Scene represents the game scene where current buffer has already been rendered.
+
 ```java
 /**
  * Scene class. Render the output frame.
@@ -222,6 +218,7 @@ public static void main(String[] args) {
 ```
 
 The console output
+
 ```text
 [main] INFO com.iluwatar.doublebuffer.Scene - Start drawing next frame
 [main] INFO com.iluwatar.doublebuffer.Scene - Current buffer: 0 Next buffer: 1
@@ -240,16 +237,43 @@ The console output
 ```
 
 ## Class diagram
-![alt text](./etc/double-buffer.urm.png "Double Buffer pattern class diagram")
+
+![Double Buffer class diagram](./etc/double-buffer.urm.png "Double Buffer pattern class diagram")
 
 ## Applicability
-This pattern is one of those ones where you’ll know when you need it. If you have a system that lacks double buffering, it will probably look visibly wrong (tearing, etc.) or will behave incorrectly. But saying, “you’ll know when you need it” doesn’t give you much to go on. More specifically, this pattern is appropriate when all of these are true:
 
-- We have some state that is being modified incrementally.
+* Real-time applications where the display needs to be updated frequently and smoothly, such as video games, simulations, and graphical user interfaces.
-- That same state may be accessed in the middle of modification.
+* Applications requiring high computational resources to prepare data, where the preparation can be done in parallel with data consumption.
-- We want to prevent the code that’s accessing the state from seeing the work in progress.
+* Scenarios where the goal is to minimize the perception of lag or stutter in the display of data or graphics.
-- We want to be able to read the state and we don’t want to have to wait while it’s being written. 
+
+## Known Uses
+
+* Graphics Rendering Engines: Used extensively in 2D and 3D rendering engines to ensure smooth animations and transitions.
+* User Interface Frameworks: Employed in GUI frameworks to enhance the responsiveness and smoothness of interfaces.
+* Simulation and Modeling: Utilized in simulations to display real-time updates without interrupting the simulation process.
+* Video Playback Software: Applied in video players to provide seamless playback by preloading the next frame while the current one is displayed.
+
+## Consequences
+
+Benefits:
+
+* Smooth User Experience: Provides a seamless display experience by pre-rendering frames, leading to smoother animations and transitions.
+* Performance Optimization: Allows intensive rendering or data preparation tasks to be performed in the background, optimizing overall performance.
+* Minimizes Flickering: Reduces or eliminates flickering and visual artifacts in graphical applications.
+
+Trade-offs:
+
+* Memory Overhead: Requires additional memory for the secondary buffer, potentially doubling the memory usage for the buffered data.
+* Implementation Complexity: Adds complexity to the system architecture, requiring careful management of the two buffers.
+* Latency: Can introduce a slight delay, as the data must be fully rendered or prepared in the back buffer before being displayed.
+
+## Related Patterns
+
+* Triple Buffering: An extension of the Double Buffer pattern, where three buffers are used to further optimize rendering and reduce latency.
+* [Producer-Consumer](https://java-design-patterns.com/patterns/producer-consumer/): The Double Buffer pattern can be seen as a variant of the Producer-Consumer pattern, with one buffer being "produced" while the other is "consumed".
+* [Strategy](https://java-design-patterns.com/patterns/strategy/): Often used in conjunction with the Strategy pattern to dynamically choose the buffering strategy based on runtime conditions.
 
 ## Credits
 
-* [Game Programming Patterns - Double Buffer](http://gameprogrammingpatterns.com/double-buffer.html)
+* [Game Programming Patterns - Double Buffer](https://amzn.to/4ayDNkS)
+* [Real-Time Design Patterns: Robust Scalable Architecture for Real-Time Systems](https://amzn.to/3xFfNxA)

double-buffer/src/main/java/com/iluwatar/doublebuffer/Pixel.java

@@ -30,5 +30,5 @@ package com.iluwatar.doublebuffer;
 public enum Pixel {
 
   WHITE,
-  BLACK;
+  BLACK
 }

pom.xml

@@ -219,6 +219,7 @@
     <module>dynamic-proxy</module>
     <module>gateway</module>
     <module>slob</module>
+    <module>server-session</module>
   </modules>
   <repositories>
     <repository>

server-session/README.md

@@ -3,9 +3,9 @@ title: Server Session
 category: Behavioral
 language: en
 tag:
-    - Session Management 
-    - Session Tracking
     - Cookies
+    - Session management 
+    - State tracking
 ---
 
 ## Also known as
@@ -20,7 +20,7 @@ Within the context of a client-server relationship, the server is responsible fo
 
 Real-world example
 
-> Consider a gaming website which stores user profile data such as username, password, highscore, hours played, etc. Since this website is accessed over the internet which uses the HTTP protocol, all requests sent to the server are stateless. In order for the page to display user relevent information without re-authenticating the user on every request a session must be created. Once the session is created the user can access the homescreen, statistics page, setting page, etc. and view profile specific data without needing to login in on every page request.
+> Consider a gaming website which stores user profile data such as username, password, high-score, hours played, etc. Since this website is accessed over the internet which uses the HTTP protocol, all requests sent to the server are stateless. In order for the page to display user relevant information without re-authenticating the user on every request a session must be created. Once the session is created the user can access the homescreen, statistics page, setting page, etc. and view profile specific data without needing to log in on every page request.
 
 In plain words
 
@@ -179,13 +179,13 @@ Sessions are often given a maximum time in which they will be maintained. The se
 
 ## Class diagram
 
-![alt text](./etc/adapter.urm.png "Adapter class diagram")
+![Server Session class diagram](./etc/server-session.urm.puml "Server Session class diagram")
 
 ## Applicability
 
 Use the Adapter pattern when
 
-* When a user logs into a website or web application and you want to keep track of their authentication status.
+* When a user logs into a website or web application, and you want to keep track of their authentication status.
 * In e-commerce websites when you want to maintain the contents of a user's shopping cart across different pages and visits.
 * When you want to store user preferences and settings, such as language preferences, theme choices, or any other customizable options. 
 * When you want to keep track of user activity and behavior on a website for the sake of analytics purposes.

server-session/etc/server-session.urm.puml

@@ -0,0 +1,27 @@
+@startuml
+package com.iluwatar.sessionserver {
+  class App {
+    - LOGGER : Logger {static}
+    - SESSION_EXPIRATION_TIME : long {static}
+    - sessionCreationTimes : Map<String, Instant> {static}
+    - sessions : Map<String, Integer> {static}
+    + App()
+    + main(args : String[]) {static}
+    - sessionExpirationTask() {static}
+  }
+  class LoginHandler {
+    - LOGGER : Logger {static}
+    - sessionCreationTimes : Map<String, Instant>
+    - sessions : Map<String, Integer>
+    + LoginHandler(sessions : Map<String, Integer>, sessionCreationTimes : Map<String, Instant>)
+    + handle(exchange : HttpExchange)
+  }
+  class LogoutHandler {
+    - LOGGER : Logger {static}
+    - sessionCreationTimes : Map<String, Instant>
+    - sessions : Map<String, Integer>
+    + LogoutHandler(sessions : Map<String, Integer>, sessionCreationTimes : Map<String, Instant>)
+    + handle(exchange : HttpExchange)
+  }
+}
+@enduml

server-session/pom.xml

@@ -9,19 +9,17 @@
         <artifactId>java-design-patterns</artifactId>
         <version>1.26.0-SNAPSHOT</version>
     </parent>
-    <artifactId>serversession</artifactId>
+    <artifactId>server-session</artifactId>
 
     <dependencies>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
-            <version>5.10.2</version>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>
-            <version>5.11.0</version>
             <scope>test</scope>
         </dependency>
     </dependencies>

server-session/src/main/java/com/iluwatar/sessionserver/App.java

@@ -1,10 +1,12 @@
 package com.iluwatar.sessionserver;
 
+import com.sun.net.httpserver.HttpServer;
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.time.Instant;
-import java.util.*;
+import java.util.HashMap;
-import com.sun.net.httpserver.HttpServer;
+import java.util.Iterator;
+import java.util.Map;
 import lombok.extern.slf4j.Slf4j;
 
 /**
@@ -32,6 +34,11 @@ public class App {
   private static Map<String, Instant> sessionCreationTimes = new HashMap<>();
   private static final long SESSION_EXPIRATION_TIME = 10000;
 
+  /**
+   * Main entry point.
+   * @param args arguments
+   * @throws IOException ex
+   */
   public static void main(String[] args) throws IOException {
     // Create HTTP server listening on port 8000
     HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);
@@ -58,7 +65,8 @@ public class App {
           Instant currentTime = Instant.now();
           synchronized (sessions) {
             synchronized (sessionCreationTimes) {
-                            Iterator<Map.Entry<String, Instant>> iterator = sessionCreationTimes.entrySet().iterator();
+              Iterator<Map.Entry<String, Instant>> iterator =
+                  sessionCreationTimes.entrySet().iterator();
               while (iterator.hasNext()) {
                 Map.Entry<String, Instant> entry = iterator.next();
                 if (entry.getValue().plusMillis(SESSION_EXPIRATION_TIME).isBefore(currentTime)) {

server-session/src/main/java/com/iluwatar/sessionserver/LoginHandler.java

@@ -2,16 +2,16 @@ package com.iluwatar.sessionserver;
 
 import com.sun.net.httpserver.HttpExchange;
 import com.sun.net.httpserver.HttpHandler;
-import lombok.extern.slf4j.Slf4j;
-import org.slf4j.Logger;
-
 import java.io.IOException;
 import java.io.OutputStream;
 import java.time.Instant;
-import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
+import lombok.extern.slf4j.Slf4j;
 
+/**
+ * LoginHandler.
+ */
 @Slf4j
 public class LoginHandler implements HttpHandler {
 
@@ -26,20 +26,19 @@ public class LoginHandler implements HttpHandler {
   @Override
   public void handle(HttpExchange exchange) {
     // Generate session ID
-        String sessionID = UUID.randomUUID().toString();
+    String sessionId = UUID.randomUUID().toString();
 
     // Store session data (simulated)
     int newUser = sessions.size() + 1;
-        sessions.put(sessionID, newUser);
+    sessions.put(sessionId, newUser);
-        sessionCreationTimes.put(sessionID, Instant.now());
+    sessionCreationTimes.put(sessionId, Instant.now());
-        LOGGER.info("User " + newUser + " created at time " + sessionCreationTimes.get(sessionID));
+    LOGGER.info("User " + newUser + " created at time " + sessionCreationTimes.get(sessionId));
 
     // Set session ID as cookie
-        exchange.getResponseHeaders().add("Set-Cookie", "sessionID=" + sessionID);
+    exchange.getResponseHeaders().add("Set-Cookie", "sessionID=" + sessionId);
 
     // Send response
-        String response = "Login successful!\n" +
+    String response = "Login successful!\n" + "Session ID: " + sessionId;
-                "Session ID: " + sessionID;
     try {
       exchange.sendResponseHeaders(200, response.length());
     } catch (IOException e) {

server-session/src/main/java/com/iluwatar/sessionserver/LogoutHandler.java

@@ -2,13 +2,15 @@ package com.iluwatar.sessionserver;
 
 import com.sun.net.httpserver.HttpExchange;
 import com.sun.net.httpserver.HttpHandler;
-import lombok.extern.slf4j.Slf4j;
-
 import java.io.IOException;
 import java.io.OutputStream;
 import java.time.Instant;
 import java.util.Map;
+import lombok.extern.slf4j.Slf4j;
 
+/**
+ * LogoutHandler.
+ */
 @Slf4j
 public class LogoutHandler implements HttpHandler {
 
@@ -23,26 +25,26 @@ public class LogoutHandler implements HttpHandler {
   @Override
   public void handle(HttpExchange exchange) {
     // Get session ID from cookie
-        String sessionID = exchange.getRequestHeaders().getFirst("Cookie").replace("sessionID=", "");
+    String sessionId = exchange.getRequestHeaders().getFirst("Cookie").replace("sessionID=", "");
-        String currentSessionID = sessions.get(sessionID) == null ? null : sessionID;
+    String currentSessionId = sessions.get(sessionId) == null ? null : sessionId;
 
     // Send response
 
     String response = "";
-        if(currentSessionID == null) {
+    if (currentSessionId == null) {
       response += "Session has already expired!";
     } else {
-            response = "Logout successful!\n" +
+      response = "Logout successful!\n" + "Session ID: " + currentSessionId;
-                    "Session ID: " + currentSessionID;
     }
 
     //Remove session
-        if(currentSessionID != null)
+    if (currentSessionId != null) {
-          LOGGER.info("User " + sessions.get(currentSessionID) + " deleted!");
+      LOGGER.info("User " + sessions.get(currentSessionId) + " deleted!");
-        else
+    } else {
       LOGGER.info("User already deleted!");
-        sessions.remove(sessionID);
+    }
-        sessionCreationTimes.remove(sessionID);
+    sessions.remove(sessionId);
+    sessionCreationTimes.remove(sessionId);
 
     try {
       exchange.sendResponseHeaders(200, response.length());

server-session/src/test/java/com.iluwatar.sessionserver/LoginHandlerTest.java

@@ -1,21 +1,23 @@
+package com.iluwatar.sessionserver;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.when;
+
 import com.sun.net.httpserver.Headers;
 import com.sun.net.httpserver.HttpExchange;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.Map;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
-import com.iluwatar.sessionserver.LoginHandler;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.time.Instant;
-import java.util.*;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
 
+/**
+ * LoginHandlerTest.
+ */
 public class LoginHandlerTest {
 
   private LoginHandler loginHandler;
@@ -26,6 +28,9 @@ public class LoginHandlerTest {
   @Mock
   private HttpExchange exchange;
 
+  /**
+   * Setup tests.
+   */
   @BeforeEach
   public void setUp() {
     MockitoAnnotations.initMocks(this);
@@ -38,8 +43,10 @@ public class LoginHandlerTest {
   public void testHandle() throws IOException {
 
     //assemble
-        ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); //Exchange object is mocked so OutputStream must be manually created
+    ByteArrayOutputStream outputStream =
-        when(exchange.getResponseHeaders()).thenReturn(new Headers()); //Exchange object is mocked so Header object must be manually created
+        new ByteArrayOutputStream(); //Exchange object is mocked so OutputStream must be manually created
+    when(exchange.getResponseHeaders()).thenReturn(
+        new Headers()); //Exchange object is mocked so Header object must be manually created
     when(exchange.getResponseBody()).thenReturn(outputStream);
 
     //act

server-session/src/test/java/com.iluwatar.sessionserver/LogoutHandlerTest.java

@@ -1,20 +1,23 @@
+package com.iluwatar.sessionserver;
+
+import static org.mockito.Mockito.when;
+
 import com.sun.net.httpserver.Headers;
 import com.sun.net.httpserver.HttpExchange;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import com.iluwatar.sessionserver.LogoutHandler;
-
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.time.Instant;
 import java.util.HashMap;
 import java.util.Map;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
 
-import static org.mockito.Mockito.when;
+/**
-
+ * LogoutHandlerTest.
+ */
 public class LogoutHandlerTest {
 
   private LogoutHandler logoutHandler;
@@ -25,6 +28,9 @@ public class LogoutHandlerTest {
   @Mock
   private HttpExchange exchange;
 
+  /**
+   * Setup tests.
+   */
   @BeforeEach
   public void setUp() {
     MockitoAnnotations.initMocks(this);
@@ -32,17 +38,19 @@ public class LogoutHandlerTest {
     sessionCreationTimes = new HashMap<>();
     logoutHandler = new LogoutHandler(sessions, sessionCreationTimes);
     headers = new Headers();
-        headers.add("Cookie", "sessionID=1234"); //Exchange object methods return Header Object but Exchange is mocked so Headers must be manually created
+    headers.add("Cookie",
+        "sessionID=1234"); //Exchange object methods return Header Object but Exchange is mocked so Headers must be manually created
   }
 
   @Test
   public void testHandler_SessionNotExpired() throws IOException {
 
     //assemble
-        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
     sessions.put("1234", 1); //Fake login details since LoginHandler isn't called
-        sessionCreationTimes.put("1234", Instant.now()); //Fake login details since LoginHandler isn't called
+    sessionCreationTimes.put("1234",
+        Instant.now()); //Fake login details since LoginHandler isn't called
     when(exchange.getRequestHeaders()).thenReturn(headers);
+    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
     when(exchange.getResponseBody()).thenReturn(outputStream);
 
     //act