fixing maven format in logaggregator2

Author: harsh543

microservices-log-aggregation/src/main/java/com/iluwatar/logaggregation/LogAggregator.java

@@ -23,15 +23,15 @@
  * THE SOFTWARE.
  */
 package com.iluwatar.logaggregation;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.CountDownLatch;
-import java.util.ArrayList;
-import java.util.List;
 import lombok.extern.slf4j.Slf4j;
 /**
  * Responsible for collecting and buffering logs from different services. Once the logs reach a
@@ -45,47 +45,51 @@ public class LogAggregator {
   private static final int BUFFER_THRESHOLD = 3;
   private static final int FLUSH_INTERVAL_SECONDS = 5;
   private static final int SHUTDOWN_TIMEOUT_SECONDS = 10;
-  
+
   private final CentralLogStore centralLogStore;
   private final BlockingQueue<LogEntry> buffer = new LinkedBlockingQueue<>();
   private final LogLevel minLogLevel;
   private final ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(1);
   private final AtomicInteger logCount = new AtomicInteger(0);
   private final CountDownLatch shutdownLatch = new CountDownLatch(1);
   private volatile boolean running = true;
+
   /**
    * constructor of LogAggregator.
    *
    * @param centralLogStore central log store implement
    * @param minLogLevel min log level to store log
    */
   public LogAggregator(CentralLogStore centralLogStore, LogLevel minLogLevel) {
-   this.centralLogStore = centralLogStore;
+    this.centralLogStore = centralLogStore;
     this.minLogLevel = minLogLevel;
     startPeriodicFlusher();
-    
+
     // Add shutdown hook for graceful termination
-    Runtime.getRuntime().addShutdownHook(new Thread(() -> {
-      try {
-        stop();
-      } catch (InterruptedException e) {
-        LOGGER.warn("Shutdown interrupted", e);
-        Thread.currentThread().interrupt();
-      }
-    }));
+    Runtime.getRuntime()
+        .addShutdownHook(
+            new Thread(
+                () -> {
+                  try {
+                    stop();
+                  } catch (InterruptedException e) {
+                    LOGGER.warn("Shutdown interrupted", e);
+                    Thread.currentThread().interrupt();
+                  }
+                }));
   }
 
   /**
    * Collects a given log entry, and filters it by the defined log level.
    *
    * @param logEntry The log entry to collect.
    */
-   public void collectLog(LogEntry logEntry) {
+  public void collectLog(LogEntry logEntry) {
     if (!running) {
       LOGGER.warn("LogAggregator is shutting down. Skipping log entry.");
       return;
     }
-    
+
     if (logEntry.getLevel() == null || minLogLevel == null) {
       LOGGER.warn("Log level or threshold level is null. Skipping.");
       return;
@@ -115,19 +119,19 @@ public void collectLog(LogEntry logEntry) {
    *
    * @throws InterruptedException If any thread has interrupted the current thread.
    */
- public void stop() throws InterruptedException {
+  public void stop() throws InterruptedException {
     LOGGER.info("Stopping LogAggregator...");
     running = false;
-    
+
     // Shutdown the scheduler gracefully
     scheduledExecutor.shutdown();
-    
+
     try {
       // Wait for scheduled tasks to complete
       if (!scheduledExecutor.awaitTermination(SHUTDOWN_TIMEOUT_SECONDS, TimeUnit.SECONDS)) {
         LOGGER.warn("Scheduler did not terminate gracefully, forcing shutdown");
         scheduledExecutor.shutdownNow();
-        
+
         // Wait a bit more for tasks to respond to interruption
         if (!scheduledExecutor.awaitTermination(2, TimeUnit.SECONDS)) {
           LOGGER.error("Scheduler did not terminate after forced shutdown");
@@ -141,57 +145,53 @@ public void stop() throws InterruptedException {
     }
   }
 
-
-
   /**
-   * Waits for the LogAggregator to complete shutdown.
-   * Useful for testing or controlled shutdown scenarios.
+   * Waits for the LogAggregator to complete shutdown. Useful for testing or controlled shutdown
+   * scenarios.
    *
    * @throws InterruptedException If any thread has interrupted the current thread.
    */
-public void awaitShutdown() throws InterruptedException {
+  public void awaitShutdown() throws InterruptedException {
     shutdownLatch.await();
   }
 
-
   private void flushBuffer() {
     if (!running && buffer.isEmpty()) {
       return;
     }
-    
+
     try {
       List<LogEntry> batch = new ArrayList<>();
       int drained = 0;
-      
+
       // Drain up to a reasonable batch size for efficiency
       LogEntry logEntry;
       while ((logEntry = buffer.poll()) != null && drained < 100) {
         batch.add(logEntry);
         drained++;
       }
-      
+
       if (!batch.isEmpty()) {
         LOGGER.debug("Flushing {} log entries to central store", batch.size());
-        
+
         // Process the batch
         for (LogEntry entry : batch) {
           centralLogStore.storeLog(entry);
           logCount.decrementAndGet();
         }
-        
+
         LOGGER.debug("Successfully flushed {} log entries", batch.size());
       }
     } catch (Exception e) {
       LOGGER.error("Error occurred while flushing buffer", e);
     }
   }
 
-
   /**
-   * Starts the periodic buffer flusher using ScheduledExecutorService.
-   * This eliminates the busy-waiting loop with Thread.sleep().
+   * Starts the periodic buffer flusher using ScheduledExecutorService. This eliminates the
+   * busy-waiting loop with Thread.sleep().
    */
-   private void startPeriodicFlusher() {
+  private void startPeriodicFlusher() {
     scheduledExecutor.scheduleAtFixedRate(
         () -> {
           if (running) {
@@ -202,16 +202,16 @@ private void startPeriodicFlusher() {
             }
           }
         },
-        FLUSH_INTERVAL_SECONDS,  // Initial delay
-        FLUSH_INTERVAL_SECONDS,  // Period
-        TimeUnit.SECONDS
-    );
-    
-    LOGGER.info("Periodic log flusher started with interval of {} seconds", FLUSH_INTERVAL_SECONDS);
+        FLUSH_INTERVAL_SECONDS, // Initial delay
+        FLUSH_INTERVAL_SECONDS, // Period
+        TimeUnit.SECONDS);
+
+    LOGGER.info(
+        "Periodic log flusher started with interval of {} seconds", FLUSH_INTERVAL_SECONDS);
   }
+
   /**
-   * Gets the current number of buffered log entries.
-   * Useful for monitoring and testing.
+   * Gets the current number of buffered log entries. Useful for monitoring and testing.
    *
    * @return Current buffer size
    */
@@ -220,8 +220,7 @@ public int getBufferSize() {
   }
 
   /**
-   * Gets the current log count.
-   * Useful for monitoring and testing.
+   * Gets the current log count. Useful for monitoring and testing.
    *
    * @return Current log count
    */

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

@@ -22,23 +22,20 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-package com.iluwatar.sessionserver;
+package com.iluwatar.logaggregation;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.mockito.Mockito.when;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
-import com.sun.net.httpserver.Headers;
-import com.sun.net.httpserver.HttpExchange;
-import java.io.ByteArrayOutputStream;
-import java.time.Instant;
-import java.util.HashMap;
-import java.util.Map;
+import java.time.LocalDateTime;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.jupiter.MockitoExtension;
 
-/** LoginHandlerTest. */
+@ExtendWith(MockitoExtension.class)
 public class LoginHandlerTest {
 
   private LoginHandler loginHandler;
@@ -47,7 +44,6 @@ public class LoginHandlerTest {
   private Map<String, Instant> sessionCreationTimes;
 
   @Mock private HttpExchange exchange;
-
   /** Setup tests. */
   @BeforeEach
   public void setUp() {