chore(deps): bump redis-cloud to v0.10.0 and redis-enterprise to v0.9.1 (#935)

Author: joshrotenberg

Cargo.lock

@@ -99,9 +99,8 @@ pretty_assertions = "1.4"
 redis = { version = "0.27", features = ["tokio-comp", "tokio-rustls-comp", "connection-manager", "cluster-async"] }
 
 # External crates (git for dev, version required for crates.io publish)
-# TODO: revert to branch = "main" once redis-developer/redis-cloud-rs#103 merges.
-redis-cloud = { version = "0.9.5", git = "https://github.com/redis-developer/redis-cloud-rs", branch = "fix/task-error-object-deserialization" }
-redis-enterprise = { version = "0.8.5", git = "https://github.com/redis-developer/redis-enterprise-rs", branch = "main" }
+redis-cloud = { version = "0.10.0" }
+redis-enterprise = { version = "0.9.1" }
 
 # Windows CI workaround - ensure these are available in workspace
 shellexpand = "3.1"

Cargo.toml

@@ -7,7 +7,7 @@
 
 use crate::enterprise::progress::{EnterpriseProgressCallback, poll_action};
 use crate::error::Result;
-use redis_enterprise::bdb::DatabaseUpgradeRequest;
+use redis_enterprise::bdb::{DatabaseActionResponse, DatabaseUpgradeRequest, ModuleUpgrade};
 use redis_enterprise::{Database, EnterpriseClient};
 use std::time::Duration;
 
@@ -97,10 +97,19 @@ pub async fn upgrade_module_and_wait(
     timeout: Duration,
     on_progress: Option<EnterpriseProgressCallback>,
 ) -> Result<Database> {
-    // Submit the module upgrade request
+    // Submit the module upgrade as part of a database upgrade request. The
+    // dedicated module-upgrade method was folded into the upgrade endpoint
+    // upstream; modules are now carried in the `modules` field.
+    let request = DatabaseUpgradeRequest::builder()
+        .modules(vec![ModuleUpgrade {
+            module_name: module_name.to_string(),
+            new_version: Some(new_version.to_string()),
+            module_args: None,
+        }])
+        .build();
     let action = client
         .databases()
-        .upgrade(bdb_uid, module_name, new_version)
+        .upgrade_redis_version(bdb_uid, request)
         .await?;
 
     // Poll until completion
@@ -137,13 +146,24 @@ pub async fn backup_database_and_wait(
     timeout: Duration,
     on_progress: Option<EnterpriseProgressCallback>,
 ) -> Result<()> {
-    // Trigger backup
-    let response = client.databases().backup(bdb_uid).await?;
+    // Trigger backup. The dedicated `backup` handler method was removed
+    // upstream; POST the backup action directly (BDB.BACKUP).
+    let response: DatabaseActionResponse = client
+        .post(
+            &format!("/v1/bdbs/{}/actions/backup", bdb_uid),
+            &serde_json::json!({}),
+        )
+        .await?;
 
-    // Poll until completion if we got an action_uid
-    if let Some(action_uid) = response.action_uid {
-        poll_action(client, &action_uid, timeout, DEFAULT_INTERVAL, on_progress).await?;
-    }
+    // Poll until completion
+    poll_action(
+        client,
+        &response.action_uid,
+        timeout,
+        DEFAULT_INTERVAL,
+        on_progress,
+    )
+    .await?;
 
     Ok(())
 }

crates/redisctl-core/src/enterprise/workflows.rs

@@ -6,6 +6,7 @@
 
 use crate::error::{CoreError, Result};
 use redis_cloud::tasks::TaskStateUpdate;
+use redis_cloud::types::TaskStatus;
 use redis_cloud::{CloudClient, TaskHandler};
 use std::time::{Duration, Instant};
 
@@ -102,21 +103,24 @@ pub async fn poll_task(
         }
 
         let task = handler.get_task_by_id(task_id.to_string()).await?;
-        let status = task.status.clone().unwrap_or_default();
+        let status = task.status.clone();
+        let status_label = task_status_label(status.as_ref());
 
         emit(
             &on_progress,
             ProgressEvent::Polling {
                 task_id: task_id.to_string(),
-                status: status.clone(),
+                status: status_label.clone(),
                 elapsed,
             },
         );
 
-        // Check for terminal states (case-insensitive)
-        match status.to_lowercase().as_str() {
-            // Success states
-            "processing-completed" | "completed" | "complete" | "succeeded" | "success" => {
+        // Check for terminal states. `TaskStatus` only models the two terminal
+        // states explicitly; everything else (Initialized, Received,
+        // ProcessingInProgress, and any Unknown wire value) is still in flight.
+        match status {
+            // Success
+            Some(TaskStatus::ProcessingCompleted) => {
                 let resource_id = task.response.as_ref().and_then(|r| r.resource_id);
                 emit(
                     &on_progress,
@@ -127,13 +131,13 @@ pub async fn poll_task(
                 );
                 return Ok(task);
             }
-            // Failure states
-            "processing-error" | "failed" | "error" => {
+            // Failure
+            Some(TaskStatus::ProcessingError) => {
                 let error = task
                     .response
                     .as_ref()
                     .and_then(|r| r.error_message())
-                    .unwrap_or_else(|| format!("Task failed with status: {}", status));
+                    .unwrap_or_else(|| format!("Task failed with status: {}", status_label));
 
                 emit(
                     &on_progress,
@@ -144,19 +148,8 @@ pub async fn poll_task(
                 );
                 return Err(CoreError::TaskFailed(error));
             }
-            // Cancelled state
-            "cancelled" => {
-                emit(
-                    &on_progress,
-                    ProgressEvent::Failed {
-                        task_id: task_id.to_string(),
-                        error: "Task was cancelled".to_string(),
-                    },
-                );
-                return Err(CoreError::TaskFailed("Task was cancelled".to_string()));
-            }
+            // Still processing, wait and try again
             _ => {
-                // Still processing, wait and try again
                 tokio::time::sleep(interval).await;
             }
         }
@@ -170,6 +163,22 @@ fn emit(callback: &Option<ProgressCallback>, event: ProgressEvent) {
     }
 }
 
+/// Human-readable label for a task status, mirroring the kebab-case wire form.
+///
+/// Used for progress events and failure messages. A missing status (or one the
+/// client doesn't recognize) is reported as `"unknown"`.
+fn task_status_label(status: Option<&TaskStatus>) -> String {
+    match status {
+        Some(TaskStatus::Initialized) => "initialized",
+        Some(TaskStatus::Received) => "received",
+        Some(TaskStatus::ProcessingInProgress) => "processing-in-progress",
+        Some(TaskStatus::ProcessingCompleted) => "processing-completed",
+        Some(TaskStatus::ProcessingError) => "processing-error",
+        Some(TaskStatus::Unknown) | None => "unknown",
+    }
+    .to_string()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/redisctl-core/src/progress.rs

@@ -6,6 +6,7 @@ use redis_cloud::acl::{
     AclUserUpdateRequest,
 };
 use redis_cloud::cloud_accounts::{CloudAccountCreateRequest, CloudAccountUpdateRequest};
+use redis_cloud::types::TaskStatus;
 use redis_cloud::users::AccountUserUpdateRequest;
 use redis_cloud::{
     AccountHandler, AclHandler, CloudAccountHandler, CostReportCreateRequest, CostReportHandler,
@@ -688,20 +689,13 @@ cloud_tool!(read_only, wait_for_cloud_task, "wait_for_cloud_task",
                 .await
                 .tool_context("Failed to get task status")?;
 
-            // Check for terminal states
-            if let Some(ref status) = task.status {
-                let s = status.to_lowercase();
-                if matches!(
-                    s.as_str(),
-                    "completed"
-                        | "failed"
-                        | "error"
-                        | "success"
-                        | "cancelled"
-                        | "aborted"
-                ) {
-                    return CallToolResult::from_serialize(&task);
-                }
+            // Check for terminal states. `TaskStatus` models only the two
+            // terminal states explicitly; everything else is still in flight.
+            if matches!(
+                task.status,
+                Some(TaskStatus::ProcessingCompleted) | Some(TaskStatus::ProcessingError)
+            ) {
+                return CallToolResult::from_serialize(&task);
             }
 
             // Check timeout