review from @tishun

- attemp to increase readibility and establish a clear seperation of responsibilties via breaking tokenmanager into multiple classes and interfaces.
- added some comments to explain the logic

Author: atakavci

core/src/main/java/redis/clients/authentication/core/Dispatcher.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2024, Redis Ltd. and Contributors All rights reserved. Licensed under the MIT License.
+ */
+package redis.clients.authentication.core;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Dispatches requests to the identity provider asynchronously with a timeout for the request execution.
+ */
+class Dispatcher {
+    private ExecutorService executor = Executors.newFixedThreadPool(2);
+    private Exception error;
+    private long tokenRequestExecTimeoutInMs;
+    private IdentityProvider identityProvider;
+    private Logger logger = LoggerFactory.getLogger(getClass());
+
+    public Dispatcher(IdentityProvider provider, long tokenRequestExecTimeoutInMs) {
+        this.tokenRequestExecTimeoutInMs = tokenRequestExecTimeoutInMs;
+        this.identityProvider = provider;
+    }
+
+    /**
+     * Dispatches a request to the identity provider asynchronously 
+     * with a timeout for the request execution and returns the request object
+     * @return
+     */
+    public Request requestTokenAsync() {
+        Future<Token> request = executor.submit(() -> requestToken());
+        return () -> request.get(tokenRequestExecTimeoutInMs, TimeUnit.MILLISECONDS);
+    }
+
+    public Exception getError() {
+        return error;
+    }
+
+    public void stop() {
+        executor.shutdown();
+    }
+
+    /**
+     * Makes the actual request to the identity provider
+     * @return
+     */
+    private Token requestToken() {
+        error = null;
+        try {
+            return identityProvider.requestToken();
+        } catch (Exception e) {
+            error = e;
+            logger.error("Request to identity provider failed with message: " + e.getMessage(), e);
+            throw e;
+        }
+    }
+}

core/src/main/java/redis/clients/authentication/core/RenewalScheduler.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2024, Redis Ltd. and Contributors All rights reserved. Licensed under the MIT License.
+ */
+package redis.clients.authentication.core;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+
+/**
+ * Schedules a task for token renewal.
+ */
+class RenewalScheduler {
+    private ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+    private RenewalTask lastTask;
+    private Supplier<Token> renewToken;
+    private boolean stopped = false;
+
+    public RenewalScheduler(Supplier<Token> renewToken) {
+        this.renewToken = renewToken;
+    }
+
+    /**
+     * Schedules a task to renew the token with a given delay
+     * Wraps the supplier function into RenewalTask
+     * @param delay
+     * @return
+     */
+    public RenewalTask scheduleNext(long delay) {
+        // Schedule the task to run after the given delay
+        lastTask = new RenewalTask(
+                scheduler.schedule(() -> renewToken.get(), delay, TimeUnit.MILLISECONDS));
+        return lastTask;
+    }
+
+    /**
+     * Returns the last task that was scheduled
+     * @return
+     */
+    public RenewalTask getLastTask() {
+        return lastTask;
+    }
+
+    /**
+     * Waits for given task to complete
+     * If there is an execution error in the task, it throws the same exception
+     * It keeps following if there are consecutive tasks until a non-null result is returned or an exception occurs
+     * This makes the caller thread to wait until a first token is received with or after the pendingTask
+     * @param pendingTask
+     * @throws InterruptedException
+     * @throws ExecutionException
+     */
+    public void waitFor(RenewalTask pendingTask) throws InterruptedException, ExecutionException {
+        while (!stopped && pendingTask.waitForResultOrError() == null) {
+            pendingTask = getLastTask();
+        }
+    }
+
+    public void stop() {
+        stopped = true;
+        lastTask.cancel();
+        scheduler.shutdown();
+    }
+}

core/src/main/java/redis/clients/authentication/core/RenewalTask.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2024, Redis Ltd. and Contributors
+ * All rights reserved.
+ *
+ * Licensed under the MIT License.
+ */
+package redis.clients.authentication.core;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ScheduledFuture;
+
+class RenewalTask {
+
+    private ScheduledFuture<Token> future;
+
+    public RenewalTask(ScheduledFuture<Token> future) {
+        this.future = future;
+    }
+
+    public Token waitForResultOrError() throws InterruptedException, ExecutionException {
+        return future.get();
+    }
+
+    public void cancel() {
+        future.cancel(true);
+    }
+}

core/src/main/java/redis/clients/authentication/core/Request.java

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2024, Redis Ltd. and Contributors
+ * All rights reserved.
+ *
+ * Licensed under the MIT License.
+ */
+package redis.clients.authentication.core;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeoutException;
+
+interface Request {
+
+    public Token getResult() throws InterruptedException, ExecutionException, TimeoutException;
+}