Add benchmarking application. No test clients yet.

java/benchmarks/build.gradle

@@ -18,6 +18,9 @@ dependencies {
     implementation 'io.lettuce:lettuce-core:6.2.6.RELEASE'
     implementation 'commons-cli:commons-cli:1.5.0'
     implementation group: 'org.apache.commons', name: 'commons-lang3', version: '3.13.0'
+    implementation group: 'org.apache.commons', name: 'commons-math3', version: '3.5'
+    implementation group: 'com.google.code.gson', name: 'gson', version: '2.10.1'
+
 }
 
 // Apply a specific Java toolchain to ease working on different environments.
@@ -32,7 +35,7 @@ application {
     mainClass = 'javababushka.benchmarks.BenchmarkingApp'
 }
 
-tasks.withType(Test) { 
+tasks.withType(Test) {
   testLogging {
     exceptionFormat "full"
     events "started", "skipped", "passed", "failed"

java/benchmarks/src/main/java/javababushka/benchmarks/BenchmarkingApp.java

@@ -1,7 +1,5 @@
 package javababushka.benchmarks;
 
-import java.io.FileWriter;
-import java.io.IOException;
 import java.util.Arrays;
 import java.util.Optional;
 import java.util.stream.Stream;
@@ -37,40 +35,24 @@ public static void main(String[] args) {
       runConfiguration = verifyOptions(line);
     } catch (ParseException exp) {
       // oops, something went wrong
-      System.err.println("Parsing failed.  Reason: " + exp.getMessage());
+      System.err.println("Parsing failed. Reason: " + exp.getMessage());
     }
 
     for (ClientName client : runConfiguration.clients) {
       switch (client) {
         case JEDIS:
-          // run testClientSetGet on JEDIS sync client
-          System.out.println("Run JEDIS sync client");
-          break;
-        case JEDIS_ASYNC:
-          // run testClientSetGet on JEDIS pseudo-async client
-          System.out.println("Run JEDIS pseudo-async client");
+          // run testClientSetGet on JEDIS pseudo-sync client
+          System.out.println("Run JEDIS async client");
           break;
         case LETTUCE:
-          // run testClientSetGet on LETTUCE sync client
-          System.out.println("Run LETTUCE sync client");
-          break;
-        case LETTUCE_ASYNC:
           // run testClientSetGet on LETTUCE async client
           System.out.println("Run LETTUCE async client");
           break;
-        case BABUSHKA_ASYNC:
+        case BABUSHKA:
           System.out.println("Babushka async not yet configured");
           break;
       }
     }
-
-    if (runConfiguration.resultsFile.isPresent()) {
-      try {
-        runConfiguration.resultsFile.get().close();
-      } catch (IOException ioException) {
-        System.out.println("Error closing results file: " + ioException.getLocalizedMessage());
-      }
-    }
   }
 
   private static Options getOptions() {
@@ -96,15 +78,21 @@ private static Options getOptions() {
         Option.builder("clients")
             .hasArg(true)
             .desc(
-                "one of:"
-                    + " all|jedis|jedis_async|lettuce|lettuce_async|babushka_async|all_async|all_sync"
-                    + " [all]")
+                "one of: all|jedis|jedis_async|lettuce|lettuce_async|"
+                    + "babushka|babushka_async|all_async|all_sync")
             .build());
     options.addOption(Option.builder("host").hasArg(true).desc("Hostname [localhost]").build());
     options.addOption(Option.builder("port").hasArg(true).desc("Port number [6379]").build());
     options.addOption(
         Option.builder("clientCount").hasArg(true).desc("Number of clients to run [1]").build());
     options.addOption(Option.builder("tls").hasArg(false).desc("TLS [false]").build());
+    options.addOption(
+        Option.builder("clusterModeEnabled")
+            .hasArg(false)
+            .desc("Is cluster-mode enabled, other standalone mode is used [false]")
+            .build());
+    options.addOption(
+        Option.builder("debugLogging").hasArg(false).desc("Verbose logs [false]").build());
 
     return options;
   }
@@ -123,16 +111,11 @@ private static RunConfiguration verifyOptions(CommandLine line) throws ParseExce
     }
 
     if (line.hasOption("resultsFile")) {
-      String resultsFileName = line.getOptionValue("resultsFile");
-      try {
-        runConfiguration.resultsFile = Optional.of(new FileWriter(resultsFileName));
-      } catch (IOException ioException) {
-        throw new ParseException(
-            "Unable to write to resultsFile ("
-                + resultsFileName
-                + "): "
-                + ioException.getMessage());
-      }
+      runConfiguration.resultsFile = Optional.ofNullable(line.getOptionValue("resultsFile"));
+    }
+
+    if (line.hasOption("dataSize")) {
+      runConfiguration.dataSize = parseIntListOption(line.getOptionValue("dataSize"));
     }
 
     if (line.hasOption("concurrentTasks")) {
@@ -148,22 +131,7 @@ private static RunConfiguration verifyOptions(CommandLine line) throws ParseExce
                   e -> {
                     switch (e) {
                       case ALL:
-                        return Stream.of(
-                            ClientName.JEDIS,
-                            ClientName.JEDIS_ASYNC,
-                            //                            ClientName.BABUSHKA_ASYNC,
-                            ClientName.LETTUCE,
-                            ClientName.LETTUCE_ASYNC);
-                      case ALL_ASYNC:
-                        return Stream.of(
-                            ClientName.JEDIS_ASYNC,
-                            // ClientName.BABUSHKA_ASYNC,
-                            ClientName.LETTUCE_ASYNC);
-                      case ALL_SYNC:
-                        return Stream.of(
-                            ClientName.JEDIS,
-                            // ClientName.BABUSHKA_ASYNC,
-                            ClientName.LETTUCE);
+                        return Stream.of(ClientName.JEDIS, ClientName.BABUSHKA, ClientName.LETTUCE);
                       default:
                         return Stream.of(e);
                     }
@@ -184,6 +152,8 @@ private static RunConfiguration verifyOptions(CommandLine line) throws ParseExce
     }
 
     runConfiguration.tls = line.hasOption("tls");
+    runConfiguration.clusterModeEnabled = line.hasOption("clusterModeEnabled");
+    runConfiguration.debugLogging = line.hasOption("debugLogging");
 
     return runConfiguration;
   }
@@ -195,23 +165,23 @@ private static int[] parseIntListOption(String line) throws ParseException {
     if (lineValue.startsWith("[") && lineValue.endsWith("]")) {
       lineValue = lineValue.substring(1, lineValue.length() - 1);
     }
+
+    // trim whitespace
+    lineValue = lineValue.trim();
+
     // check if it's the correct format
-    if (!lineValue.matches("\\d+(\\s+\\d+)?")) {
+    if (!lineValue.matches("\\d+(\\s+\\d+)*")) {
       throw new ParseException("Invalid option: " + line);
     }
     // split the string into a list of integers
     return Arrays.stream(lineValue.split("\\s+")).mapToInt(Integer::parseInt).toArray();
   }
 
   public enum ClientName {
-    JEDIS("Jedis"),
-    JEDIS_ASYNC("Jedis async"),
-    LETTUCE("Lettuce"),
-    LETTUCE_ASYNC("Lettuce async"),
-    BABUSHKA_ASYNC("Babushka async"),
-    ALL("All"),
-    ALL_SYNC("All sync"),
-    ALL_ASYNC("All async");
+    JEDIS("Jedis"), // async
+    LETTUCE("Lettuce"), // async
+    BABUSHKA("Babushka"), // async
+    ALL("All");
 
     private String name;
 
@@ -231,30 +201,31 @@ public boolean isEqual(String other) {
 
   public static class RunConfiguration {
     public String configuration;
-    public Optional<FileWriter> resultsFile;
+    public Optional<String> resultsFile;
     public int[] dataSize;
     public int[] concurrentTasks;
     public ClientName[] clients;
     public String host;
     public int port;
     public int[] clientCount;
     public boolean tls;
+    public boolean clusterModeEnabled;
     public boolean debugLogging = false;
 
     public RunConfiguration() {
       configuration = "Release";
       resultsFile = Optional.empty();
       dataSize = new int[] {100, 4000};
-      concurrentTasks = new int[] {100, 1000};
+      concurrentTasks = new int[] {1, 10, 100, 1000};
       clients =
           new ClientName[] {
-            // ClientName.BABUSHKA_ASYNC,
-            ClientName.JEDIS, ClientName.JEDIS_ASYNC, ClientName.LETTUCE, ClientName.LETTUCE_ASYNC
+            ClientName.ALL,
           };
       host = "localhost";
       port = 6379;
       clientCount = new int[] {1};
       tls = false;
+      clusterModeEnabled = false;
     }
   }
 }

java/benchmarks/src/main/java/javababushka/benchmarks/clients/AsyncClient.java

@@ -0,0 +1,36 @@
+package javababushka.benchmarks.clients;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/** A Redis client with async capabilities */
+public interface AsyncClient<T> extends Client {
+
+  long DEFAULT_TIMEOUT_MILLISECOND = 1000;
+
+  Future<T> asyncSet(String key, String value);
+
+  Future<String> asyncGet(String key);
+
+  default <T> T waitForResult(Future<T> future) {
+    return waitForResult(future, DEFAULT_TIMEOUT_MILLISECOND);
+  }
+
+  default <T> T waitForResult(Future<T> future, long timeout) {
+    try {
+      return future.get(timeout, TimeUnit.MILLISECONDS);
+    } catch (TimeoutException ignored) {
+      return null;
+    } catch (ExecutionException e) {
+      throw new RuntimeException("Client error", e);
+    } catch (InterruptedException e) {
+      if (Thread.currentThread().isInterrupted()) {
+        // restore interrupt
+        Thread.interrupted();
+      }
+      throw new RuntimeException("The thread was interrupted", e);
+    }
+  }
+}

java/benchmarks/src/main/java/javababushka/benchmarks/clients/Client.java

@@ -0,0 +1,12 @@
+package javababushka.benchmarks.clients;
+
+import javababushka.benchmarks.utils.ConnectionSettings;
+
+/** A Redis client interface */
+public interface Client {
+  void connectToRedis(ConnectionSettings connectionSettings);
+
+  default void closeConnection() {}
+
+  String getName();
+}

java/benchmarks/src/main/java/javababushka/benchmarks/clients/SyncClient.java

@@ -0,0 +1,8 @@
+package javababushka.benchmarks.clients;
+
+/** A Redis client with sync capabilities */
+public interface SyncClient extends Client {
+  void set(String key, String value);
+
+  String get(String key);
+}