Implement extended cache operations and update API URL handling in CLI

Co-authored-by: Copilot <copilot@github.com>

Author: bhf

.github/workflows/test.yml

@@ -46,9 +46,6 @@ jobs:
         # Extract the API URL and ensure it ends with /cache
         if [ -f "$ENV_FILE" ]; then
           API_URL=$(grep AERON_CACHE_API "$ENV_FILE" | cut -d'=' -f2)
-          if [[ "$API_URL" != */cache ]]; then
-            API_URL="${API_URL%/}/cache"
-          fi
           echo "Found API URL: $API_URL"
           echo "AERON_CACHE_API_URL=$API_URL" >> $GITHUB_ENV
         else

README.md

@@ -1,5 +1,6 @@
 # Aeron Cache CLI
 
+
 [![CI](https://github.com/bhf/aeron-cache-cli/actions/workflows/test.yml/badge.svg)](https://github.com/bhf/aeron-cache-cli/actions/workflows/test.yml)
 
 A CLI on top of the [Aeron Cache](https://github.com/bhf/aeron-cache) REST API.
@@ -12,6 +13,25 @@ Built in Rust 🦀 using:
 * [Serde](https://github.com/serde-rs/serde)
 
 
-You can also specify the URL of the Aeron-Cache API in an environment variable called ```AERON_CACHE_API_URL``` for convenience.
-
 [![asciinema demo](https://asciinema.org/a/JPbih6gJuwFHZxhj9Op64UKgN.svg)](https://asciinema.org/a/JPbih6gJuwFHZxhj9Op64UKgN)
+
+
+By default, the CLI assumes that your backend cache service is reachable at `http://localhost:7070/api/v1`. If you need to override the API base URL, use the `--api-url` flag or the `AERON_CACHE_API_URL` environment variable.
+
+## Available commands
+
+It exposes the following commands:
+- `create <name>`: Create a new cache
+- `delete <name>`: Delete a cache
+- `get-cache <name>`: Get all items from a cache
+- `clear-cache <name>`: Clear all items from a cache
+- `insert <name> <key> <value>`: Insert an item into a cache
+- `get <name> <key>`: Get an item from a cache
+- `remove <name> <key>`: Remove an item from a cache
+- `list-caches`: List all available caches and their item count
+- `stats`: Get global cache statistics
+
+Use the `--help` flag anytime for more information.
+
+Example: `cargo run -- create mycache`
+Example: `cargo run -- --api-url http://otherhost:7070/api/v1 stats`

src/cacheresponses.rs

@@ -75,3 +75,55 @@ pub(crate) enum DeleteItemResult {
     Ok(DeleteItemResponse),
     Err(ErrorResponse),
 }
+
+#[allow(non_snake_case)]
+#[derive(serde::Deserialize, Debug)]
+pub(crate) struct CacheItem {
+    pub(crate) key: String,
+    pub(crate) value: String,
+}
+
+#[allow(non_snake_case)]
+#[derive(serde::Deserialize, Debug)]
+pub(crate) struct GetCacheResponse {
+    pub(crate) cacheId: String,
+    pub(crate) status: String,
+    pub(crate) items: Vec<CacheItem>,
+}
+
+#[derive(serde::Deserialize, Debug)]
+#[serde(untagged)]
+pub(crate) enum GetCacheResult {
+    Ok(GetCacheResponse),
+    Err(ErrorResponse),
+}
+
+#[allow(non_snake_case)]
+#[derive(serde::Deserialize, Debug)]
+pub(crate) struct ClearCacheResponse {
+    pub(crate) cacheId: String,
+    pub(crate) status: String,
+}
+
+#[derive(serde::Deserialize, Debug)]
+#[serde(untagged)]
+pub(crate) enum ClearCacheResult {
+    Ok(ClearCacheResponse),
+    Err(ErrorResponse),
+}
+
+#[allow(non_snake_case)]
+#[derive(serde::Deserialize, Debug)]
+pub(crate) struct CacheDetails {
+    pub(crate) cacheId: String,
+    pub(crate) itemCount: i64,
+}
+
+#[allow(non_snake_case)]
+#[derive(serde::Deserialize, Debug)]
+pub(crate) struct CacheStatsResponse {
+    pub(crate) totalOps: i32,
+    pub(crate) totalCaches: i32,
+    pub(crate) totalItems: i32,
+    pub(crate) errorCount: i32,
+}

src/commands.rs

@@ -14,7 +14,7 @@ pub(crate) fn process_get_item(
 ) -> Result<(), Box<dyn Error>> {
 
     let url = &format!(
-        "{}/{}/{}",
+        "{}/cache/{}/{}",
         aeron_cache_api_url, cache_name, key
     );
 
@@ -47,7 +47,7 @@ pub(crate) fn process_remove_item(
 ) -> Result<(), Box<dyn Error>> {
 
     let url = &format!(
-        "{}/{}/{}",
+        "{}/cache/{}/{}",
         aeron_cache_api_url, cache_name, key
     );
 
@@ -107,7 +107,7 @@ pub(crate) fn process_insert_item(
         value: &value,
     };
 
-    let url = &format!("{}/{}", aeron_cache_api_url, cache_name);
+    let url = &format!("{}/cache/{}", aeron_cache_api_url, cache_name);
 
     let put_item_response = rest_client
         .post(url)
@@ -136,7 +136,7 @@ pub(crate) fn process_create_cache(
 ) -> Result<(), Box<dyn Error>> {
     let create_cache_request = CreateRequest { cacheId: name };
 
-    let formatted_url = &format!("{}", aeron_cache_api_url);
+    let formatted_url = &format!("{}/cache", aeron_cache_api_url);
 
     let create_cache_response = rest_client
         .post(formatted_url)
@@ -157,3 +157,99 @@ pub(crate) fn process_create_cache(
 
     Ok(())
 }
+
+pub(crate) fn process_get_cache(
+    rest_client: &Client,
+    aeron_cache_api_url: &str,
+    cache_name: &String,
+) -> Result<(), Box<dyn Error>> {
+    let url = &format!("{}/cache/{}", aeron_cache_api_url, cache_name);
+    let response = rest_client.get(url).send()?;
+    let body = response.text()?;
+    let result: crate::cacheresponses::GetCacheResult = serde_json::from_str(&body)?;
+
+    match result {
+        crate::cacheresponses::GetCacheResult::Ok(resp) => {
+            println!("Cache ID: {}", resp.cacheId);
+            println!("Status: {}", resp.status);
+            if resp.items.is_empty() {
+                println!("No items in cache.");
+            } else {
+                for item in resp.items {
+                    println!("Key: {}, Value: {}", item.key, item.value);
+                }
+            }
+        }
+        crate::cacheresponses::GetCacheResult::Err(err) => {
+            println!("Error: {}", err.errorMsg);
+            println!("Help: {}", err.helpMsg);
+        }
+    }
+    Ok(())
+}
+
+pub(crate) fn process_clear_cache(
+    rest_client: &Client,
+    aeron_cache_api_url: &str,
+    cache_name: &String,
+) -> Result<(), Box<dyn Error>> {
+    let url = &format!("{}/cache/{}", aeron_cache_api_url, cache_name);
+    let response = rest_client.patch(url).send()?;
+    let body = response.text()?;
+    let result: crate::cacheresponses::ClearCacheResult = serde_json::from_str(&body)?;
+
+    match result {
+        crate::cacheresponses::ClearCacheResult::Ok(resp) => {
+            println!("Cleared cache: {}", resp.cacheId);
+        }
+        crate::cacheresponses::ClearCacheResult::Err(err) => {
+            println!("Error: {}", err.errorMsg);
+            println!("Help: {}", err.helpMsg);
+        }
+    }
+    Ok(())
+}
+
+pub(crate) fn process_list_caches(
+    rest_client: &Client,
+    aeron_cache_api_url: &str,
+) -> Result<(), Box<dyn Error>> {
+    let url = &format!("{}/caches", aeron_cache_api_url);
+    let response = rest_client.get(url).send()?;
+    let body = response.text()?;
+    
+    // According to openapi.yaml, GET /api/v1/caches returns an array of CacheDetails directly.
+    // If it's an error, it might not be ErrorResponse? The spec doesn't list 400 for GetCaches, just 200.
+    // We can try to parse as array or ErrorResponse. Let's just parse as array.
+    if let Ok(caches) = serde_json::from_str::<Vec<crate::cacheresponses::CacheDetails>>(&body) {
+        if caches.is_empty() {
+            println!("No caches found.");
+        } else {
+            for cache in caches {
+                println!("Cache ID: {}, Items: {}", cache.cacheId, cache.itemCount);
+            }
+        }
+    } else {
+        println!("Error parsing response: {}", body);
+    }
+    Ok(())
+}
+
+pub(crate) fn process_get_stats(
+    rest_client: &Client,
+    aeron_cache_api_url: &str,
+) -> Result<(), Box<dyn Error>> {
+    let url = &format!("{}/stats", aeron_cache_api_url);
+    let response = rest_client.get(url).send()?;
+    let body = response.text()?;
+    if let Ok(stats) = serde_json::from_str::<crate::cacheresponses::CacheStatsResponse>(&body) {
+        println!("Cache Statistics:");
+        println!("Total Ops: {}", stats.totalOps);
+        println!("Total Caches: {}", stats.totalCaches);
+        println!("Total Items: {}", stats.totalItems);
+        println!("Error Count: {}", stats.errorCount);
+    } else {
+        println!("Error parsing response: {}", body);
+    }
+    Ok(())
+}

src/main.rs

@@ -18,7 +18,7 @@ use commands::*;
 struct Cli {
     #[arg(
         long,
-        default_value = "http://localhost:7070/api/v1/cache",
+        default_value = "http://localhost:7070/api/v1",
         help = "Aeron Cache API base URL"
     )]
     api_url: String,
@@ -68,19 +68,37 @@ enum Commands {
         #[arg(short, long, help = "Automatically confirm deletion")]
         yes: bool,
     },
+
+    #[command(about = "Get all items from a cache")]
+    GetCache {
+        #[arg(help = "Name of the cache")]
+        name: String,
+    },
+
+    #[command(about = "Clear all items from a cache")]
+    ClearCache {
+        #[arg(help = "Name of the cache to clear")]
+        name: String,
+    },
+
+    #[command(about = "List all caches")]
+    ListCaches,
+
+    #[command(about = "Get global cache statistics")]
+    Stats,
 }
 
 fn main() -> Result<(), Box<dyn Error>> {
     let cli = Cli::parse();
     let rest_client = Client::new();
 
     // Check CLI arg, then env var, then default
-    let aeron_cache_api_url = if cli.api_url != "http://localhost:7070/api/v1/cache" {
+    let aeron_cache_api_url = if cli.api_url != "http://localhost:7070/api/v1" {
         cli.api_url
     } else if let Ok(val) = env::var("AERON_CACHE_API_URL") {
         val
     } else {
-        "http://localhost:7070/api/v1/cache".to_string()
+        "http://localhost:7070/api/v1".to_string()
     };
 
     match cli.command {
@@ -109,6 +127,18 @@ fn main() -> Result<(), Box<dyn Error>> {
                 println!("Cache '{}' not deleted", name)
             }
         }
+        Commands::GetCache { name: cache_name } => {
+            process_get_cache(&rest_client, &aeron_cache_api_url, &cache_name)?;
+        }
+        Commands::ClearCache { name: cache_name } => {
+            process_clear_cache(&rest_client, &aeron_cache_api_url, &cache_name)?;
+        }
+        Commands::ListCaches => {
+            process_list_caches(&rest_client, &aeron_cache_api_url)?;
+        }
+        Commands::Stats => {
+            process_get_stats(&rest_client, &aeron_cache_api_url)?;
+        }
     }
     Ok(())
 }

tests/integration_test.rs

@@ -3,7 +3,7 @@ use predicates::prelude::*;
 use std::env;
 
 fn get_api_url() -> String {
-    env::var("AERON_CACHE_API_URL").unwrap_or_else(|_| "http://localhost:7070/api/v1/cache".to_string())
+    env::var("AERON_CACHE_API_URL").unwrap_or_else(|_| "http://localhost:7070/api/v1".to_string())
 }
 
 #[test]
@@ -59,3 +59,47 @@ fn test_cache_lifecycle() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
+
+#[test]
+fn test_extended_cache_operations() -> Result<(), Box<dyn std::error::Error>> {
+    let api_url = get_api_url();
+    let cache_name = "test-extended-cache-operations-cache";
+
+    // Create Cache
+    let mut cmd = Command::cargo_bin("CacheCLI")?;
+    cmd.args(&["--api-url", &api_url, "create", cache_name]);
+    cmd.assert().success();
+
+    // Insert Item
+    let mut cmd = Command::cargo_bin("CacheCLI")?;
+    cmd.args(&["--api-url", &api_url, "insert", cache_name, "mytestkey", "mytestvalue"]);
+    cmd.assert().success();
+
+    // Get Cache
+    let mut cmd = Command::cargo_bin("CacheCLI")?;
+    cmd.args(&["--api-url", &api_url, "get-cache", cache_name]);
+    // Might contain "Key: mytestkey, Value: mytestvalue"
+    cmd.assert().success().stdout(predicate::str::contains("Key: mytestkey, Value: mytestvalue"));
+
+    // Clear Cache
+    let mut cmd = Command::cargo_bin("CacheCLI")?;
+    cmd.args(&["--api-url", &api_url, "clear-cache", cache_name]);
+    cmd.assert().success().stdout(predicate::str::contains("Cleared cache:"));
+
+    // List Caches
+    let mut cmd = Command::cargo_bin("CacheCLI")?;
+    cmd.args(&["--api-url", &api_url, "list-caches"]);
+    cmd.assert().success();
+
+    // Stats
+    let mut cmd = Command::cargo_bin("CacheCLI")?;
+    cmd.args(&["--api-url", &api_url, "stats"]);
+    cmd.assert().success().stdout(predicate::str::contains("Cache Statistics:"));
+
+    // Cleanup
+    let mut cmd = Command::cargo_bin("CacheCLI")?;
+    cmd.args(&["--api-url", &api_url, "delete", cache_name, "--yes"]);
+    cmd.assert().success();
+
+    Ok(())
+}