Support Server-assisted Client-side Caching

pom.xml

@@ -75,6 +75,8 @@
 			<version>2.11.0</version>
 		</dependency>
 
+		<!-- Optional dependencies -->
+
 		<!-- UNIX socket connection support -->
 		<dependency>
 			<groupId>com.kohlschutter.junixsocket</groupId>
@@ -90,6 +92,7 @@
 			<version>1.20.0</version>
 			<scope>test</scope>
 		</dependency>
+
 		<!-- test -->
 		<dependency>
 			<groupId>junit</groupId>

src/main/java/redis/clients/jedis/CommandArguments.java

@@ -3,9 +3,12 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Iterator;
+import java.util.List;
 
 import redis.clients.jedis.annots.Experimental;
+import redis.clients.jedis.annots.Internal;
 import redis.clients.jedis.args.Rawable;
 import redis.clients.jedis.args.RawableFactory;
 import redis.clients.jedis.commands.ProtocolCommand;
@@ -17,6 +20,8 @@ public class CommandArguments implements Iterable<Rawable> {
   private CommandKeyArgumentPreProcessor keyPreProc = null;
   private final ArrayList<Rawable> args;
 
+  private List<Object> keys;
+
   private boolean blocking;
 
   private CommandArguments() {
@@ -26,6 +31,8 @@ private CommandArguments() {
   public CommandArguments(ProtocolCommand command) {
     args = new ArrayList<>();
     args.add(command);
+
+    keys = Collections.emptyList();
   }
 
   public ProtocolCommand getCommand() {
@@ -127,9 +134,24 @@ public CommandArguments key(Object key) {
       throw new IllegalArgumentException("\"" + key.toString() + "\" is not a valid argument.");
     }
 
+    addKeyInKeys(key);
+
     return this;
   }
 
+  private void addKeyInKeys(Object key) {
+    if (keys.isEmpty()) {
+      keys = Collections.singletonList(key);
+    } else if (keys.size() == 1) {
+      List oldKeys = keys;
+      keys = new ArrayList();
+      keys.addAll(oldKeys);
+      keys.add(key);
+    } else {
+      keys.add(key);
+    }
+  }
+
   public final CommandArguments keys(Object... keys) {
     Arrays.stream(keys).forEach(this::key);
     return this;
@@ -178,6 +200,11 @@ public Iterator<Rawable> iterator() {
     return args.iterator();
   }
 
+  @Internal
+  public List<Object> getKeys() {
+    return keys;
+  }
+
   public boolean isBlocking() {
     return blocking;
   }

src/main/java/redis/clients/jedis/CommandObject.java

@@ -1,5 +1,8 @@
 package redis.clients.jedis;
 
+import java.util.Iterator;
+import redis.clients.jedis.args.Rawable;
+
 public class CommandObject<T> {
 
   private final CommandArguments arguments;
@@ -17,4 +20,39 @@ public CommandArguments getArguments() {
   public Builder<T> getBuilder() {
     return builder;
   }
+
+  @Override
+  public int hashCode() {
+    int hashCode = 1;
+    for (Rawable e : arguments) {
+      hashCode = 31 * hashCode + e.hashCode();
+    }
+    hashCode = 31 * hashCode + builder.hashCode();
+    return hashCode;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (o == this) {
+      return true;
+    }
+    if (!(o instanceof CommandObject)) {
+      return false;
+    }
+
+    Iterator<Rawable> e1 = arguments.iterator();
+    Iterator<Rawable> e2 = ((CommandObject) o).arguments.iterator();
+    while (e1.hasNext() && e2.hasNext()) {
+      Rawable o1 = e1.next();
+      Rawable o2 = e2.next();
+      if (!(o1 == null ? o2 == null : o1.equals(o2))) {
+        return false;
+      }
+    }
+    if (e1.hasNext() || e2.hasNext()) {
+      return false;
+    }
+
+    return builder == ((CommandObject) o).builder;
+  }
 }

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

@@ -12,6 +12,7 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 import java.util.function.Supplier;
 
 import redis.clients.jedis.Protocol.Command;
@@ -31,7 +32,7 @@
 public class Connection implements Closeable {
 
   private ConnectionPool memberOf;
-  private RedisProtocol protocol;
+  protected RedisProtocol protocol;
   private final JedisSocketFactory socketFactory;
   private Socket socket;
   private RedisOutputStream outputStream;
@@ -41,6 +42,8 @@ public class Connection implements Closeable {
   private boolean broken = false;
   private boolean strValActive;
   private String strVal;
+  protected String server;
+  protected String version;
 
   public Connection() {
     this(Protocol.DEFAULT_HOST, Protocol.DEFAULT_PORT);
@@ -55,9 +58,7 @@ public Connection(final HostAndPort hostAndPort) {
   }
 
   public Connection(final HostAndPort hostAndPort, final JedisClientConfig clientConfig) {
-    this(new DefaultJedisSocketFactory(hostAndPort, clientConfig));
-    this.infiniteSoTimeout = clientConfig.getBlockingSocketTimeoutMillis();
-    initializeFromClientConfig(clientConfig);
+    this(new DefaultJedisSocketFactory(hostAndPort, clientConfig), clientConfig);
   }
 
   public Connection(final JedisSocketFactory socketFactory) {
@@ -373,16 +374,40 @@ protected void flush() {
     }
   }
 
+  @Experimental
+  protected Object protocolRead(RedisInputStream is) {
+    return Protocol.read(is);
+  }
+
+  @Experimental
+  protected void protocolReadPushes(RedisInputStream is) {
+  }
+
   protected Object readProtocolWithCheckingBroken() {
     if (broken) {
       throw new JedisConnectionException("Attempting to read from a broken connection.");
     }
 
     try {
-      return Protocol.read(inputStream);
-//      Object read = Protocol.read(inputStream);
-//      System.out.println(redis.clients.jedis.util.SafeEncoder.encodeObject(read));
-//      return read;
+      return protocolRead(inputStream);
+    } catch (JedisConnectionException exc) {
+      broken = true;
+      throw exc;
+    }
+  }
+
+  protected void readPushesWithCheckingBroken() {
+    if (broken) {
+      throw new JedisConnectionException("Attempting to read from a broken connection.");
+    }
+
+    try {
+      if (inputStream.available() > 0) {
+        protocolReadPushes(inputStream);
+      }
+    } catch (IOException e) {
+      broken = true;
+      throw new JedisConnectionException("Failed to check buffer on connection.", e);
     } catch (JedisConnectionException exc) {
       setBroken();
       throw exc;
@@ -404,6 +429,7 @@ public List<Object> getMany(final int count) {
 
   /**
    * Check if the client name libname, libver, characters are legal
+   *
    * @param info the name
    * @return Returns true if legal, false throws exception
    * @throws JedisException if characters illegal
@@ -419,7 +445,7 @@ private static boolean validateClientInfo(String info) {
     return true;
   }
 
-  private void initializeFromClientConfig(final JedisClientConfig config) {
+  protected void initializeFromClientConfig(final JedisClientConfig config) {
     try {
       connect();
 
@@ -430,12 +456,12 @@ private void initializeFromClientConfig(final JedisClientConfig config) {
         final RedisCredentialsProvider redisCredentialsProvider = (RedisCredentialsProvider) credentialsProvider;
         try {
           redisCredentialsProvider.prepare();
-          helloOrAuth(protocol, redisCredentialsProvider.get());
+          helloAndAuth(protocol, redisCredentialsProvider.get());
         } finally {
           redisCredentialsProvider.cleanUp();
         }
       } else {
-        helloOrAuth(protocol, credentialsProvider != null ? credentialsProvider.get()
+        helloAndAuth(protocol, credentialsProvider != null ? credentialsProvider.get()
             : new DefaultRedisCredentials(config.getUser(), config.getPassword()));
       }
 
@@ -447,7 +473,9 @@ private void initializeFromClientConfig(final JedisClientConfig config) {
       }
 
       ClientSetInfoConfig setInfoConfig = config.getClientSetInfoConfig();
-      if (setInfoConfig == null) setInfoConfig = ClientSetInfoConfig.DEFAULT;
+      if (setInfoConfig == null) {
+        setInfoConfig = ClientSetInfoConfig.DEFAULT;
+      }
 
       if (!setInfoConfig.isDisabled()) {
         String libName = JedisMetaInfo.getArtifactId();
@@ -492,50 +520,56 @@ private void initializeFromClientConfig(final JedisClientConfig config) {
     }
   }
 
-  private void helloOrAuth(final RedisProtocol protocol, final RedisCredentials credentials) {
-
-    if (credentials == null || credentials.getPassword() == null) {
-      if (protocol != null) {
-        sendCommand(Command.HELLO, encode(protocol.version()));
-        getOne();
+  private void helloAndAuth(final RedisProtocol protocol, final RedisCredentials credentials) {
+    Map<String, Object> helloResult = null;
+    if (protocol != null && credentials != null && credentials.getUser() != null) {
+      byte[] rawPass = encodeToBytes(credentials.getPassword());
+      try {
+        helloResult = hello(encode(protocol.version()), Keyword.AUTH.getRaw(), encode(credentials.getUser()), rawPass);
+      } finally {
+        Arrays.fill(rawPass, (byte) 0); // clear sensitive data
       }
-      return;
+    } else {
+      auth(credentials);
+      helloResult = protocol == null ? null : hello(encode(protocol.version()));
+    }
+    if (helloResult != null) {
+      server = (String) helloResult.get("server");
+      version = (String) helloResult.get("version");
     }
 
-    // Source: https://stackoverflow.com/a/9670279/4021802
-    ByteBuffer passBuf = Protocol.CHARSET.encode(CharBuffer.wrap(credentials.getPassword()));
-    byte[] rawPass = Arrays.copyOfRange(passBuf.array(), passBuf.position(), passBuf.limit());
-    Arrays.fill(passBuf.array(), (byte) 0); // clear sensitive data
+    // clearing 'char[] credentials.getPassword()' should be
+    // handled in RedisCredentialsProvider.cleanUp()
+  }
 
+  private void auth(RedisCredentials credentials) {
+    if (credentials == null || credentials.getPassword() == null) {
+      return;
+    }
+    byte[] rawPass = encodeToBytes(credentials.getPassword());
     try {
-      /// actual HELLO or AUTH -->
-      if (protocol != null) {
-        if (credentials.getUser() != null) {
-          sendCommand(Command.HELLO, encode(protocol.version()),
-              Keyword.AUTH.getRaw(), encode(credentials.getUser()), rawPass);
-          getOne(); // Map
-        } else {
-          sendCommand(Command.AUTH, rawPass);
-          getStatusCodeReply(); // OK
-          sendCommand(Command.HELLO, encode(protocol.version()));
-          getOne(); // Map
-        }
-      } else { // protocol == null
-        if (credentials.getUser() != null) {
-          sendCommand(Command.AUTH, encode(credentials.getUser()), rawPass);
-        } else {
-          sendCommand(Command.AUTH, rawPass);
-        }
-        getStatusCodeReply(); // OK
+      if (credentials.getUser() == null) {
+        sendCommand(Command.AUTH, rawPass);
+      } else {
+        sendCommand(Command.AUTH, encode(credentials.getUser()), rawPass);
       }
-      /// <-- actual HELLO or AUTH
     } finally {
-
       Arrays.fill(rawPass, (byte) 0); // clear sensitive data
     }
+    getStatusCodeReply();
+  }
 
-    // clearing 'char[] credentials.getPassword()' should be
-    // handled in RedisCredentialsProvider.cleanUp()
+  protected Map<String, Object> hello(byte[]... args) {
+    sendCommand(Command.HELLO, args);
+    return BuilderFactory.ENCODED_OBJECT_MAP.build(getOne());
+  }
+
+  protected byte[] encodeToBytes(char[] chars) {
+    // Source: https://stackoverflow.com/a/9670279/4021802
+    ByteBuffer passBuf = Protocol.CHARSET.encode(CharBuffer.wrap(chars));
+    byte[] rawPass = Arrays.copyOfRange(passBuf.array(), passBuf.position(), passBuf.limit());
+    Arrays.fill(passBuf.array(), (byte) 0); // clear sensitive data
+    return rawPass;
   }
 
   public String select(final int index) {