Another attempt to loop through client/concurrent tasks

.github/workflows/java-benchmark.yml

@@ -0,0 +1,46 @@
+name: Java client benchmarks
+
+on:
+  workflow_dispatch:
+    inputs:
+      name:
+        required: false
+        type: string
+
+run-name: ${{ inputs.name == '' && format('{0} @ {1}', github.ref_name, github.sha) || inputs.name }}
+
+jobs:
+  java-benchmark:
+    strategy:
+      matrix:
+        java:
+          - 11
+          - 17
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up JDK ${{ matrix.java }}
+        uses: actions/setup-java@v3
+        with:
+          distribution: "temurin"
+          java-version: ${{ matrix.java }}
+
+      - name: Start Redis
+        run: docker run -p 6379:6379 -p 8001:8001 -d redis/redis-stack
+
+      - name: Run benchmarks
+        working-directory: java/jabushka
+        run: ./gradlew :benchmark:run
+
+      - name: Upload test reports
+        if: always()
+        continue-on-error: true
+        uses: actions/upload-artifact@v3
+        with:
+          name: test-reports-${{ matrix.java }}
+          path: |
+            java/jabushka/benchmarks/build/reports/**

.github/workflows/java.yml

@@ -0,0 +1,63 @@
+name: SQL Java CI
+
+on:
+  pull_request:
+  push:
+    paths:
+      - "java/**"
+      - ".github/workflows/java.yml"
+
+# Run only most latest job on a branch and cancel previous ones
+concurrency:
+  group: ${{ github.head_ref || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build-and-test-java-client:
+    strategy:
+      # Run all jobs
+      fail-fast: false
+      matrix:
+        java:
+          - 11
+          - 17
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up JDK ${{ matrix.java }}
+        uses: actions/setup-java@v3
+        with:
+          distribution: "temurin"
+          java-version: ${{ matrix.java }}
+
+      - name: Install and run protoc (protobuf)
+        run: |
+          sudo apt update
+          sudo apt install -y protobuf-compiler
+          mkdir -p java/jabushka/jabushka/src/main/java/org/babushka/jabushka/generated
+          protoc -Iprotobuf=babushka-core/src/protobuf/ --java_out=java/jabushka/jabushka/src/main/java/org/babushka/jabushka/generated babushka-core/src/protobuf/*.proto
+
+      - name: Build rust part
+        working-directory: java
+        run: cargo build
+
+      - name: Start Redis
+        run: docker run -p 6379:6379 -p 8001:8001 -d redis/redis-stack
+
+      - name: Build java part
+        working-directory: java/jabushka
+        run: ./gradlew --continue build
+
+      - name: Upload test reports
+        if: always()
+        continue-on-error: true
+        uses: actions/upload-artifact@v3
+        with:
+          name: test-reports-${{ matrix.java }}
+          path: |
+            java/jabushka/jabushka/build/reports/**
+            java/jabushka/integTest/build/reports/**

.github/workflows/lint-ts.yml

@@ -5,10 +5,12 @@ on:
         paths:
             - benchmarks/node/**
             - node/**
+            - benchmarks/utilities/*
     pull_request:
         paths:
             - benchmarks/node/**
             - node/**
+            - benchmarks/utilities/*
 
 env:
     CARGO_TERM_COLOR: always

.gitignore

@@ -4,6 +4,9 @@
 debug/
 target/
 
+# Git stuff
+.worktrees
+
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
 Cargo.lock
@@ -17,6 +20,14 @@ dump.rdb
 .env
 benchmarks/results
 
+# IDE generaged files
+.vs
+.vscode
+.idea
+
+# MacOS metadata
+.DS_Store
+
 # lock files
 
 yarn.lock

babushka-core/src/client/mod.rs

@@ -1,18 +1,18 @@
 use crate::connection_request::{
     AddressInfo, AuthenticationInfo, ConnectionRequest, ReadFromReplicaStrategy, TlsMode,
 };
-pub use client_cmd::ClientCMD;
 use futures::FutureExt;
 use redis::cluster_async::ClusterConnection;
 use redis::cluster_routing::{RoutingInfo, SingleNodeRoutingInfo};
 use redis::{
     aio::{ConnectionLike, ConnectionManager, MultiplexedConnection},
     RedisResult,
 };
+pub use standalone_client::StandaloneClient;
 use std::io;
 use std::time::Duration;
-mod client_cmd;
 mod reconnecting_connection;
+mod standalone_client;
 
 pub const HEARTBEAT_SLEEP_DURATION: Duration = Duration::from_secs(1);
 
@@ -78,8 +78,8 @@ pub(super) fn get_connection_info(
 
 #[derive(Clone)]
 pub enum ClientWrapper {
-    CMD(ClientCMD),
-    CME {
+    Standalone(StandaloneClient),
+    Cluster {
         client: ClusterConnection,
         read_from_replicas: bool,
     },
@@ -109,9 +109,9 @@ impl Client {
     ) -> redis::RedisFuture<'a, redis::Value> {
         run_with_timeout(self.response_timeout, async {
             match self.internal_client {
-                ClientWrapper::CMD(ref mut client) => client.send_packed_command(cmd).await,
+                ClientWrapper::Standalone(ref mut client) => client.send_packed_command(cmd).await,
 
-                ClientWrapper::CME {
+                ClientWrapper::Cluster {
                     ref mut client,
                     read_from_replicas,
                 } => {
@@ -133,11 +133,11 @@ impl Client {
     ) -> redis::RedisFuture<'a, Vec<redis::Value>> {
         (async move {
             match self.internal_client {
-                ClientWrapper::CMD(ref mut client) => {
+                ClientWrapper::Standalone(ref mut client) => {
                     client.send_packed_commands(cmd, offset, count).await
                 }
 
-                ClientWrapper::CME {
+                ClientWrapper::Cluster {
                     ref mut client,
                     read_from_replicas: _,
                 } => {
@@ -205,16 +205,16 @@ async fn create_cluster_client(
 
 #[derive(thiserror::Error)]
 pub enum ConnectionError {
-    CMD(client_cmd::ClientCMDConnectionError),
-    CME(redis::RedisError),
+    Standalone(standalone_client::StandaloneClientConnectionError),
+    Cluster(redis::RedisError),
     Timeout,
 }
 
 impl std::fmt::Debug for ConnectionError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::CMD(arg0) => f.debug_tuple("CMD").field(arg0).finish(),
-            Self::CME(arg0) => f.debug_tuple("CME").field(arg0).finish(),
+            Self::Standalone(arg0) => f.debug_tuple("Standalone").field(arg0).finish(),
+            Self::Cluster(arg0) => f.debug_tuple("Cluster").field(arg0).finish(),
             Self::Timeout => write!(f, "Timeout"),
         }
     }
@@ -223,8 +223,8 @@ impl std::fmt::Debug for ConnectionError {
 impl std::fmt::Display for ConnectionError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            ConnectionError::CMD(err) => write!(f, "{err:?}"),
-            ConnectionError::CME(err) => write!(f, "{err}"),
+            ConnectionError::Standalone(err) => write!(f, "{err:?}"),
+            ConnectionError::Cluster(err) => write!(f, "{err}"),
             ConnectionError::Timeout => f.write_str("connection attempt timed out"),
         }
     }
@@ -243,16 +243,16 @@ impl Client {
             let internal_client = if request.cluster_mode_enabled {
                 let (client, read_from_replicas) = create_cluster_client(request)
                     .await
-                    .map_err(ConnectionError::CME)?;
-                ClientWrapper::CME {
+                    .map_err(ConnectionError::Cluster)?;
+                ClientWrapper::Cluster {
                     client,
                     read_from_replicas,
                 }
             } else {
-                ClientWrapper::CMD(
-                    ClientCMD::create_client(request)
+                ClientWrapper::Standalone(
+                    StandaloneClient::create_client(request)
                         .await
-                        .map_err(ConnectionError::CMD)?,
+                        .map_err(ConnectionError::Standalone)?,
                 )
             };