Java: Update JedisPool implementation and add UnifiedJedis initial setup for cluster support (#4647)

* Java: Update JedisPool implementation

Signed-off-by: Prateek Kumar <prateek.kumar@improving.com>
Signed-off-by: Alex Rehnby-Martin <alex.rehnby-martin@improving.com>

Author: prateek-kumar-improving

java/client/src/main/java/module-info.java

@@ -22,7 +22,12 @@
     exports redis.clients.jedis.resps;
     exports redis.clients.jedis.util;
 
+    // Open Jedis compatibility layer for reflection access in tests
+    opens redis.clients.jedis to
+            glide.integTest;
+
     requires java.logging; // required by shadowed protobuf
+    requires java.management; // required by Apache Commons Pool for JMX
     requires static lombok;
     requires org.apache.commons.lang3;
     requires org.apache.commons.pool2; // Required for Jedis compatibility layer

java/client/src/main/java/redis/clients/jedis/ClusterConfigurationMapper.java

@@ -0,0 +1,39 @@
+/** Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0 */
+package redis.clients.jedis;
+
+import java.util.Set;
+
+/** Connection provider for Valkey Cluster. This is part of the Jedis compatibility layer. */
+public class ClusterConnectionProvider implements ConnectionProvider {
+
+    private final Set<HostAndPort> nodes;
+    private final JedisClientConfig clientConfig;
+
+    public ClusterConnectionProvider(Set<HostAndPort> nodes, JedisClientConfig clientConfig) {
+        this.nodes = nodes;
+        this.clientConfig = clientConfig;
+    }
+
+    @Override
+    public Connection getConnection() {
+        // Return connection to first node for compatibility
+        HostAndPort firstNode = nodes.iterator().next();
+        return new Connection(firstNode);
+    }
+
+    @Override
+    public JedisClientConfig getClientConfig() {
+        return clientConfig;
+    }
+
+    /** Get all configured cluster nodes */
+    public Set<HostAndPort> getNodes() {
+        return nodes;
+    }
+
+    @Override
+    public void close() {
+        // Implementation for closing cluster connections
+        // No real connection to close since GLIDE manages them internally
+    }
+}

java/client/src/main/java/redis/clients/jedis/ClusterConnectionProvider.java

@@ -276,21 +276,10 @@ private static void mapAdvancedSettings(
 
         boolean hasAdvancedConfig = false;
 
-        // Connection timeout
-        if (jedisConfig.getConnectionTimeoutMillis() != jedisConfig.getSocketTimeoutMillis()) {
+        // Connection timeout - always map if specified
+        if (jedisConfig.getConnectionTimeoutMillis() > 0) {
             advancedBuilder.connectionTimeout(jedisConfig.getConnectionTimeoutMillis());
             hasAdvancedConfig = true;
-
-            // Log warning about different timeouts
-            if (jedisConfig.getConnectionTimeoutMillis() > 0
-                    && jedisConfig.getSocketTimeoutMillis() > 0) {
-                logger.warning(
-                        String.format(
-                                "Different connection (%dms) and socket (%dms) timeouts specified. GLIDE will use"
-                                        + " connection timeout for connection establishment and socket timeout for"
-                                        + " request timeout.",
-                                jedisConfig.getConnectionTimeoutMillis(), jedisConfig.getSocketTimeoutMillis()));
-            }
         }
 
         // Handle blocking socket timeout - warn about architectural difference

java/client/src/main/java/redis/clients/jedis/ConfigurationMapper.java

@@ -1,22 +1,34 @@
 /** Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0 */
 package redis.clients.jedis;
 
-/** Connection compatibility stub for Valkey GLIDE wrapper. */
-public class Connection {
+import java.io.Closeable;
 
-    public void close() {
-        // Stub implementation
+/** Represents a connection to a server. This is part of the Jedis compatibility layer. */
+public class Connection implements Closeable {
+
+    private final HostAndPort hostAndPort;
+
+    public Connection(HostAndPort hostAndPort) {
+        this.hostAndPort = hostAndPort;
     }
 
-    public boolean isConnected() {
-        return true;
+    /** Get the host and port for this connection */
+    public HostAndPort getHostAndPort() {
+        return hostAndPort;
     }
 
+    /** Get the host */
     public String getHost() {
-        return "localhost";
+        return hostAndPort.getHost();
     }
 
+    /** Get the port */
     public int getPort() {
-        return 6379;
+        return hostAndPort.getPort();
+    }
+
+    @Override
+    public void close() {
+        // Implementation for closing connection
     }
 }

java/client/src/main/java/redis/clients/jedis/Connection.java

@@ -3,31 +3,28 @@
 
 import redis.clients.jedis.util.Pool;
 
-/** ConnectionPool compatibility stub for Valkey GLIDE wrapper. */
+/**
+ * ConnectionPool compatibility stub for Valkey GLIDE wrapper.
+ *
+ * @deprecated ConnectionPool is not supported in the GLIDE compatibility layer. Use JedisPool for
+ *     connection pooling instead. See <a
+ *     href="https://github.com/valkey-io/valkey-glide/blob/main/java/MIGRATION.md">Migration
+ *     guide</a> for more details.
+ */
+@Deprecated
 public class ConnectionPool extends Pool<Connection> {
 
-    @Override
-    public Connection getResource() {
-        return new Connection();
-    }
-
-    @Override
-    public void returnResource(Connection resource) {
-        // Stub implementation
-    }
-
-    @Override
-    public void returnBrokenResource(Connection resource) {
-        // Stub implementation
-    }
-
-    @Override
-    public void destroy() {
-        // Stub implementation
+    public ConnectionPool() {
+        throw new UnsupportedOperationException(
+                "ConnectionPool is not supported in GLIDE compatibility layer. GLIDE uses a different"
+                        + " connection management architecture. Please use JedisPool for connection pooling"
+                        + " instead. See migration guide:"
+                        + " https://github.com/valkey-io/valkey-glide/blob/main/java/MIGRATION.md");
     }
 
     @Override
-    public boolean isClosed() {
-        return false;
+    public Connection getResource() {
+        throw new UnsupportedOperationException(
+                "ConnectionPool is not supported in GLIDE compatibility layer. Use JedisPool instead.");
     }
 }

java/client/src/main/java/redis/clients/jedis/ConnectionPool.java

@@ -0,0 +1,21 @@
+/** Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0 */
+package redis.clients.jedis;
+
+import java.io.Closeable;
+
+/**
+ * Interface for providing connections to Redis instances. This is part of the Jedis compatibility
+ * layer.
+ */
+public interface ConnectionProvider extends Closeable {
+
+    /** Get a connection from the provider */
+    Connection getConnection();
+
+    /** Get the client configuration */
+    JedisClientConfig getClientConfig();
+
+    /** Close the provider and all its connections */
+    @Override
+    void close();
+}

java/client/src/main/java/redis/clients/jedis/ConnectionProvider.java

@@ -0,0 +1,167 @@
+/** Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0 */
+package redis.clients.jedis;
+
+import glide.api.GlideClient;
+import glide.api.logging.Logger;
+import glide.api.models.configuration.GlideClientConfiguration;
+import java.util.concurrent.ExecutionException;
+import org.apache.commons.pool2.PooledObject;
+import org.apache.commons.pool2.PooledObjectFactory;
+import org.apache.commons.pool2.impl.DefaultPooledObject;
+import redis.clients.jedis.exceptions.JedisException;
+
+/**
+ * Factory for creating and managing Jedis instances backed by GLIDE clients in a connection pool.
+ * This factory implements the Apache Commons Pool PooledObjectFactory interface to provide proper
+ * connection lifecycle management.
+ */
+public class GlideJedisFactory implements PooledObjectFactory<Jedis> {
+
+    private final String host;
+    private final int port;
+    private final JedisClientConfig clientConfig;
+    private JedisPool pool; // Pool reference set after factory creation
+
+    /**
+     * Create a new factory for Jedis connections.
+     *
+     * @param host the Redis/Valkey server host
+     * @param port the Redis/Valkey server port
+     * @param clientConfig the client configuration
+     */
+    public GlideJedisFactory(String host, int port, JedisClientConfig clientConfig) {
+        this.host = host;
+        this.port = port;
+        this.clientConfig = clientConfig;
+        this.pool = null; // Will be set later by JedisPool
+    }
+
+    /**
+     * Set the pool reference after factory creation. This is called by JedisPool after the factory is
+     * created but before it's used.
+     *
+     * @param pool the JedisPool that owns this factory
+     */
+    public void setPool(JedisPool pool) {
+        this.pool = pool;
+    }
+
+    @Override
+    public PooledObject<Jedis> makeObject() throws Exception {
+        try {
+            // Map Jedis configuration to GLIDE configuration
+            GlideClientConfiguration glideConfig =
+                    ConfigurationMapper.mapToGlideConfig(host, port, clientConfig);
+
+            // Create GLIDE client
+            GlideClient glideClient = GlideClient.createClient(glideConfig).get();
+
+            // Use the direct constructor following original Jedis pattern
+            // This constructor:
+            // - Takes GlideClient directly (no lazy initialization needed)
+            // - Sets isPooled = true
+            // - Sets lazyInitialized = true
+            // - Registers the resource immediately
+            Jedis jedis = new Jedis(glideClient, clientConfig);
+
+            // Set the pool reference following original Jedis pattern
+            if (pool != null) {
+                jedis.setDataSource(pool);
+            }
+
+            return new DefaultPooledObject<>(jedis);
+        } catch (InterruptedException | ExecutionException e) {
+            throw new JedisException("Failed to create Jedis connection", e);
+        }
+    }
+
+    @Override
+    public void destroyObject(PooledObject<Jedis> pooledObject) throws Exception {
+        Jedis jedis = pooledObject.getObject();
+        if (jedis != null && !jedis.isClosed()) {
+            try {
+                jedis.close();
+            } catch (Exception e) {
+                // Log error but don't throw - we're in cleanup mode
+                Logger.log(
+                        Logger.Level.WARN,
+                        "GlideJedisFactory",
+                        "Error closing Jedis connection during destroy",
+                        e);
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override
+    public boolean validateObject(PooledObject<Jedis> pooledObject) {
+        Jedis jedis = pooledObject.getObject();
+        if (jedis == null || jedis.isClosed()) {
+            return false;
+        }
+
+        try {
+            // Use ping to validate connection
+            String response = jedis.ping();
+            return "PONG".equals(response);
+        } catch (Exception e) {
+            // Connection is not valid
+            return false;
+        }
+    }
+
+    @Override
+    public void activateObject(PooledObject<Jedis> pooledObject) throws Exception {
+        // Reset any state when borrowing from pool
+        Jedis jedis = pooledObject.getObject();
+        if (jedis != null) {
+            jedis.resetForReuse();
+        }
+    }
+
+    @Override
+    public void passivateObject(PooledObject<Jedis> pooledObject) throws Exception {
+        // Clean up state when returning to pool
+        Jedis jedis = pooledObject.getObject();
+        if (jedis != null) {
+            // Reset any transaction or pipeline state
+            jedis.resetForReuse();
+        }
+    }
+
+    /**
+     * Get the host this factory connects to.
+     *
+     * @return the host
+     */
+    public String getHost() {
+        return host;
+    }
+
+    /**
+     * Get the port this factory connects to.
+     *
+     * @return the port
+     */
+    public int getPort() {
+        return port;
+    }
+
+    /**
+     * Get the client configuration used by this factory.
+     *
+     * @return the client configuration
+     */
+    public JedisClientConfig getClientConfig() {
+        return clientConfig;
+    }
+
+    /**
+     * Get the pool reference.
+     *
+     * @return the pool reference, or null if not set
+     */
+    public JedisPool getPool() {
+        return pool;
+    }
+}