feat: Added Redis configuration properties

redis-field-engineering · Jul 6, 2022 · 59e2106 · 59e2106
1 parent 357ee35
commit 59e2106
Show file tree

Hide file tree

Showing 3 changed files with 89 additions and 34 deletions.
diff --git a/core/redis-sidecar-jdbc/src/main/java/com/redis/sidecar/SidecarDriver.java b/core/redis-sidecar-jdbc/src/main/java/com/redis/sidecar/SidecarDriver.java
@@ -76,7 +76,7 @@ public Connection connect(String url, Properties info) throws SQLException {
 			throw new SQLException("Invalid connection URL: " + url);
 		}
 		config.getRedis().setUri(matcher.group(1));
-		AbstractRedisClient redisClient = redisManager.getClient(config);
+		AbstractRedisClient redisClient = redisManager.getClient(config.getRedis());
 		Connection backendConnection = backendConnection(config, info);
 		RowSetFactory rowSetFactory = RowSetProvider.newFactory();
 		try {
@@ -87,7 +87,8 @@ public Connection connect(String url, Properties info) throws SQLException {
 		MeterRegistry meterRegistry = meterRegistryManager.getRegistry(redisClient, config);
 		ByteArrayResultSetCodec codec = new ByteArrayResultSetCodec(RowSetProvider.newFactory(),
 				config.getRedis().getBufferSize(), meterRegistry);
-		GenericObjectPool<StatefulConnection<String, ResultSet>> pool = redisManager.getConnectionPool(config, codec);
+		GenericObjectPool<StatefulConnection<String, ResultSet>> pool = redisManager
+				.getConnectionPool(config.getRedis(), codec);
 		ResultSetCache cache = new StringResultSetCache(config, meterRegistry, pool, sync(redisClient));
 		return new SidecarConnection(backendConnection, config, cache, rowSetFactory, meterRegistry);
 	}

diff --git a/core/redis-sidecar-jdbc/src/main/java/com/redis/sidecar/core/RedisManager.java b/core/redis-sidecar-jdbc/src/main/java/com/redis/sidecar/core/RedisManager.java
@@ -10,50 +10,51 @@
 
 import com.redis.lettucemod.RedisModulesClient;
 import com.redis.lettucemod.cluster.RedisModulesClusterClient;
-import com.redis.sidecar.core.config.Config;
+import com.redis.sidecar.core.config.Pool;
+import com.redis.sidecar.core.config.Redis;
 
 import io.lettuce.core.AbstractRedisClient;
+import io.lettuce.core.RedisURI;
 import io.lettuce.core.api.StatefulConnection;
 import io.lettuce.core.codec.RedisCodec;
 import io.lettuce.core.support.ConnectionPoolSupport;
 
 public class RedisManager {
 
-	private final Map<String, AbstractRedisClient> clients = new HashMap<>();
-	private final Map<String, GenericObjectPool<StatefulConnection<String, ResultSet>>> pools = new HashMap<>();
+	private final Map<RedisURI, AbstractRedisClient> clients = new HashMap<>();
+	private final Map<RedisURI, GenericObjectPool<StatefulConnection<String, ResultSet>>> pools = new HashMap<>();
 
-	public AbstractRedisClient getClient(Config config) {
-		String uri = config.getRedis().getUri();
+	public AbstractRedisClient getClient(Redis redis) {
+		RedisURI uri = redis.redisURI();
 		if (!clients.containsKey(uri)) {
-			boolean cluster = config.getRedis().isCluster();
-			clients.put(uri, cluster ? RedisModulesClusterClient.create(uri) : RedisModulesClient.create(uri));
+			clients.put(uri,
+					redis.isCluster() ? RedisModulesClusterClient.create(uri) : RedisModulesClient.create(uri));
 		}
 		return clients.get(uri);
 	}
 
-	public GenericObjectPool<StatefulConnection<String, ResultSet>> getConnectionPool(Config config,
+	public GenericObjectPool<StatefulConnection<String, ResultSet>> getConnectionPool(Redis redis,
 			RedisCodec<String, ResultSet> codec) {
-		String uri = config.getRedis().getUri();
+		RedisURI uri = redis.redisURI();
 		if (!pools.containsKey(uri)) {
-			pools.put(uri, pool(config, codec));
+			AbstractRedisClient client = getClient(redis);
+			boolean cluster = redis.isCluster();
+			GenericObjectPool<StatefulConnection<String, ResultSet>> pool = ConnectionPoolSupport
+					.createGenericObjectPool(() -> cluster ? ((RedisModulesClusterClient) client).connect(codec)
+							: ((RedisModulesClient) client).connect(codec), poolConfig(redis.getPool()));
+			pools.put(uri, pool);
 		}
 		return pools.get(uri);
 	}
 
-	private GenericObjectPool<StatefulConnection<String, ResultSet>> pool(Config config,
-			RedisCodec<String, ResultSet> codec) {
-		AbstractRedisClient client = getClient(config);
-		GenericObjectPoolConfig<StatefulConnection<String, ResultSet>> poolConfig = new GenericObjectPoolConfig<>();
-		poolConfig.setMaxTotal(config.getRedis().getPool().getMaxActive());
-		poolConfig.setMaxIdle(config.getRedis().getPool().getMaxIdle());
-		poolConfig.setMinIdle(config.getRedis().getPool().getMinIdle());
-		poolConfig.setTimeBetweenEvictionRuns(
-				Duration.ofMillis(config.getRedis().getPool().getTimeBetweenEvictionRuns()));
-		poolConfig.setMaxWait(Duration.ofMillis(config.getRedis().getPool().getMaxWait()));
-		boolean cluster = config.getRedis().isCluster();
-		return ConnectionPoolSupport
-				.createGenericObjectPool(() -> cluster ? ((RedisModulesClusterClient) client).connect(codec)
-						: ((RedisModulesClient) client).connect(codec), poolConfig);
+	private GenericObjectPoolConfig<StatefulConnection<String, ResultSet>> poolConfig(Pool pool) {
+		GenericObjectPoolConfig<StatefulConnection<String, ResultSet>> config = new GenericObjectPoolConfig<>();
+		config.setMaxTotal(pool.getMaxActive());
+		config.setMaxIdle(pool.getMaxIdle());
+		config.setMinIdle(pool.getMinIdle());
+		config.setTimeBetweenEvictionRuns(Duration.ofMillis(pool.getTimeBetweenEvictionRuns()));
+		config.setMaxWait(Duration.ofMillis(pool.getMaxWait()));
+		return config;
 	}
 
 }
diff --git a/core/redis-sidecar-jdbc/src/main/java/com/redis/sidecar/core/config/Redis.java b/core/redis-sidecar-jdbc/src/main/java/com/redis/sidecar/core/config/Redis.java
@@ -1,5 +1,7 @@
 package com.redis.sidecar.core.config;
 
+import io.lettuce.core.RedisURI;
+
 public class Redis {
 
 	public static final String DEFAULT_URI = "redis://localhost:6379";
@@ -8,12 +10,47 @@ public class Redis {
 	public static final int DEFAULT_BUFFER_SIZE = 100; // MB
 
 	private String uri = DEFAULT_URI;
+	private boolean tls;
+	private boolean insecure;
 	private boolean cluster;
+	private String username;
+	private String password;
 	private String keyspace = DEFAULT_KEYSPACE;
 	private String keySeparator = DEFAULT_KEY_SEPARATOR;
 	private int bufferSize = DEFAULT_BUFFER_SIZE;
 	private Pool pool = new Pool();
 
+	public String getUri() {
+		return uri;
+	}
+
+	public void setUri(String uri) {
+		this.uri = uri;
+	}
+
+	public boolean isTls() {
+		return tls;
+	}
+
+	public void setTls(boolean tls) {
+		this.tls = tls;
+	}
+
+	public RedisURI redisURI() {
+		RedisURI redisURI = RedisURI.create(uri);
+		redisURI.setVerifyPeer(!insecure);
+		if (tls) {
+			redisURI.setSsl(tls);
+		}
+		if (username != null) {
+			redisURI.setUsername(username);
+		}
+		if (password != null) {
+			redisURI.setPassword((CharSequence) password);
+		}
+		return redisURI;
+	}
+
 	/**
 	 * 
 	 * @return max byte buffer capacity in megabytes
@@ -34,14 +71,6 @@ public String key(String keyspace, String id) {
 		return keyspace + keySeparator + id;
 	}
 
-	public String getUri() {
-		return uri;
-	}
-
-	public void setUri(String uri) {
-		this.uri = uri;
-	}
-
 	public String getKeyspace() {
 		return keyspace;
 	}
@@ -58,6 +87,30 @@ public void setKeySeparator(String keySeparator) {
 		this.keySeparator = keySeparator;
 	}
 
+	public String getUsername() {
+		return username;
+	}
+
+	public void setUsername(String username) {
+		this.username = username;
+	}
+
+	public String getPassword() {
+		return password;
+	}
+
+	public void setPassword(String password) {
+		this.password = password;
+	}
+
+	public boolean isInsecure() {
+		return insecure;
+	}
+
+	public void setInsecure(boolean insecure) {
+		this.insecure = insecure;
+	}
+
 	public boolean isCluster() {
 		return cluster;
 	}