Better tests

Author: test

src/main.rs

@@ -15,6 +15,7 @@ use storage::engine::{
     AppState, ClusterData, delete_value, get_value, get_table_store, join_cluster, put_value,
 };
 use storage::persistance::{cold_save, load_all_tables};
+use crate::storage::engine::{get_all_keys, get_multiple_keys};
 
 /// Declare APP_STATE globally so that it’s available throughout the module.
 static APP_STATE: OnceCell<web::Data<AppState>> = OnceCell::new();
@@ -214,6 +215,11 @@ async fn main() -> std::io::Result<()> {
             .route("/store", web::get().to(|state: web::Data<AppState>| async move {
                 web::Json(state.store.lock().unwrap().clone())
             }))
+            // Endpoint to get all key names in a table.
+            .route("/{table}/keys", web::get().to(get_all_keys))
+            // Endpoint to retrieve multiple keys from a table (using a JSON body).
+            .route("/{table}/keys", web::post().to(get_multiple_keys))
+
     })
         .bind(bind_addr.as_str())?
         .run()

src/storage/engine.rs

@@ -267,3 +267,47 @@ pub async fn delete_value(
     let _results = join_all(tasks).await;
     HttpResponse::Ok().body("Key deleted from all replicas")
 }
+
+/// GET /{table}/keys
+/// Returns a JSON array with all key names in the given table.
+pub async fn get_all_keys(table: web::Path<String>, state: web::Data<AppState>) -> impl Responder {
+    let table_name = table.into_inner();
+    let store = state.store.lock().unwrap();
+    if let Some(table_data) = store.get(&table_name) {
+        let keys: Vec<String> = table_data.keys().cloned().collect();
+        HttpResponse::Ok().json(keys)
+    } else {
+        HttpResponse::NotFound().body("Table not found")
+    }
+}
+
+/// Input for retrieving multiple keys.
+#[derive(Deserialize)]
+pub struct KeysRequest {
+    /// List of keys requested.
+    pub keys: Vec<String>,
+}
+
+/// POST /{table}/keys
+/// With a JSON body { "keys": ["key1", "key2", ...] },
+/// returns a JSON object mapping each found key to its stored value.
+pub async fn get_multiple_keys(
+    table: web::Path<String>,
+    keys_request: web::Json<KeysRequest>,
+    state: web::Data<AppState>,
+) -> impl Responder {
+    let table_name = table.into_inner();
+    let requested_keys = keys_request.into_inner().keys;
+    let store = state.store.lock().unwrap();
+    if let Some(table_data) = store.get(&table_name) {
+        let mut result = HashMap::new();
+        for key in requested_keys {
+            if let Some(value) = table_data.get(&key) {
+                result.insert(key, value.clone());
+            }
+        }
+        HttpResponse::Ok().json(result)
+    } else {
+        HttpResponse::NotFound().body("Table not found")
+    }
+}

test.sh

@@ -1,61 +1,114 @@
 #!/bin/bash
-# This script launches 100 nodes (one seed + 99 joiners),
-# writes a key to the seed node, waits for propagation,
-# and then performs 10 random reads to verify data consistency.
+# This script:
+#  - Clones the DynaRust binary into a unique folder for each node so that each node uses its own file system.
+#  - Launches 100 nodes (one seed and 99 joiners) from their own working directories.
+#  - Writes a key/value pair to the "default" table on the seed node.
+#  - Waits for propagation and performs random reads.
+#  - Also tests endpoints for listing keys and retrieving multiple keys.
+#  - Finally, it cleans up (kills node processes and removes the temporary directories).
 
 set -e
 
-# Trap exit signals to kill background nodes when the script exits.
-trap "kill $(jobs -p) 2>/dev/null" EXIT
+# Create a temporary directory where we'll create subdirectories for each node.
+TMP_DIR=$(mktemp -d -t dynatest.XXXXXX)
+echo "Using temporary directory: ${TMP_DIR}"
+
+# Trap exit signals to kill background nodes and cleanup TMP_DIR when the script exits.
+cleanup() {
+    echo "Cleaning up..."
+    kill $(jobs -p) 2>/dev/null || true
+    rm -rf "${TMP_DIR}"
+}
+trap cleanup EXIT
 
 # Total number of cluster nodes to start.
-NODES=100
+NODES=30
 # Base port for the first (seed) node.
 BASE_PORT=6660
 
 echo "Starting DynaRust nodes for cluster test..."
 
-# Start the seed node.
-echo "Starting seed node at 127.0.0.1:${BASE_PORT}"
-./target/release/DynaRust 127.0.0.1:${BASE_PORT} &
-# Save the PID if needed.
-PIDS=($!)
-
-# Start additional nodes joining the seed.
-for (( i=1; i<NODES; i++ )); do
-  PORT=$((BASE_PORT + i))
-  echo "Starting node at 127.0.0.1:${PORT} joining 127.0.0.1:${BASE_PORT}"
-  ./target/release/DynaRust 127.0.0.1:${PORT} 127.0.0.1:${BASE_PORT} &
-  PIDS+=($!)
+# Array to hold the PIDs of launched processes.
+PIDS=()
+
+# Start nodes. Each node will be run from its own directory under TMP_DIR.
+for (( i=0; i<NODES; i++ )); do
+    NODE_DIR="${TMP_DIR}/node${i}"
+    mkdir -p "${NODE_DIR}"
+    # Copy the binary to the node directory.
+    cp ./target/release/DynaRust "${NODE_DIR}/DynaRust"
+
+    PORT=$((BASE_PORT + i))
+
+    if [ $i -eq 0 ]; then
+        # Seed node - no join argument.
+        echo "Starting seed node at 127.0.0.1:${PORT} in ${NODE_DIR}"
+        ( cd "${NODE_DIR}" && ./DynaRust 127.0.0.1:${PORT} ) &
+        PIDS+=($!)
+    else
+        # Other nodes join the seed node.
+        echo "Starting node at 127.0.0.1:${PORT} in ${NODE_DIR}, joining 127.0.0.1:${BASE_PORT}"
+        ( cd "${NODE_DIR}" && ./DynaRust 127.0.0.1:${PORT} 127.0.0.1:${BASE_PORT} ) &
+        PIDS+=($!)
+    fi
 done
 
-# Wait for the cluster nodes to start and join.
 echo "Waiting 5 seconds for cluster stabilization..."
 sleep 5
 
-# Write a test value to the seed node.
+# Define test parameters.
+TABLE="default"
 KEY="testkey"
 VALUE="testvalue"
-echo "Writing key '$KEY' with value '$VALUE' to the seed node..."
-curl -s -X PUT "http://127.0.0.1:${BASE_PORT}/key/${KEY}" \
+
+# Write a test value to the seed node in the "default" table.
+echo "Writing key '$KEY' with value '$VALUE' to table '$TABLE' on the seed node..."
+curl -s -X PUT "http://127.0.0.1:${BASE_PORT}/${TABLE}/key/${KEY}" \
      -H "Content-Type: application/json" \
-     -d "{\"value\": \"${VALUE}\"}"
+     -d "{\"attribute\": \"${VALUE}\"}"
 echo ""
 
-# Wait 3 seconds to allow the update to propagate to all nodes.
 echo "Waiting 3 seconds for data propagation..."
 sleep 3
 
 # Perform 10 random read operations from nodes in the cluster.
 NUM_READS=10
 echo "Performing ${NUM_READS} random reads from cluster nodes..."
 for (( i=1; i<=NUM_READS; i++ )); do
-  # Using the built-in $RANDOM to generate a random index.
   NODE_INDEX=$(($RANDOM % $NODES))
   READ_PORT=$((BASE_PORT + NODE_INDEX))
   echo "Read attempt ${i} from node at 127.0.0.1:${READ_PORT}:"
-  curl -s "http://127.0.0.1:${READ_PORT}/key/${KEY}"
+  curl -s "http://127.0.0.1:${READ_PORT}/${TABLE}/key/${KEY}"
+  echo -e "\n-------------------------"
+done
+
+# Test the new endpoint to list all keys in the table from the seed node.
+echo "Listing all keys in table '$TABLE' from the seed node:"
+curl -s "http://127.0.0.1:${BASE_PORT}/${TABLE}/keys"
+echo -e "\n-------------------------"
+
+# Test the new endpoint to retrieve multiple keys from the table from the seed node.
+echo "Retrieving multiple keys from table '$TABLE' from the seed node (requesting 'testkey' and 'nonexistent'):"
+curl -s -X POST "http://127.0.0.1:${BASE_PORT}/${TABLE}/keys" \
+     -H "Content-Type: application/json" \
+     -d '{"keys": ["testkey", "nonexistent"]}'
+echo -e "\n-------------------------"
+
+# Select 3 random nodes and for each:
+# - Retrieve the test key value using GET /default/key/{key}
+# - List all keys using GET /default/keys
+echo "Selecting 3 random nodes to verify key access and key listing:"
+for (( i=1; i<=3; i++ )); do
+  NODE_INDEX=$(($RANDOM % $NODES))
+  READ_PORT=$((BASE_PORT + NODE_INDEX))
+  echo "From node at 127.0.0.1:${READ_PORT}:"
+  echo "Retrieving key '$KEY':"
+  curl -s "http://127.0.0.1:${READ_PORT}/${TABLE}/key/${KEY}"
+  echo ""
+  echo "Listing keys in table '$TABLE':"
+  curl -s "http://127.0.0.1:${READ_PORT}/${TABLE}/keys"
   echo -e "\n-------------------------"
 done
 pkill DynaRust
+
 echo "Test completed successfully."