redis-enterprise 0.8.7

Redis Enterprise REST API client library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! Action management for Redis Enterprise async operations
//!
//! ## Overview
//! - Track long-running operations
//! - Query action status
//! - Cancel or wait for actions

use crate::client::RestClient;
use crate::error::Result;
use serde::{Deserialize, Serialize};

/// Action information
/// Represents an action (operation) in the cluster
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Action {
    /// Action's unique identifier (read-only)
    pub action_uid: String,
    /// Action's name (read-only)
    pub name: String,
    /// Current status of the action
    ///
    /// Possible values: 'queued', 'starting', 'running', 'cancelling', 'cancelled', 'completed', 'failed'
    pub status: String,
    /// Percent of completed steps in current action (0-100)
    pub progress: Option<f32>,
    /// ISO 8601 timestamp when the action was started
    pub start_time: Option<String>,
    /// ISO 8601 timestamp when the action completed or failed
    pub end_time: Option<String>,
    /// Human-readable description of the action
    pub description: Option<String>,
    /// Error message if the action failed
    pub error: Option<String>,
    /// Database UID associated with the action
    pub bdb_uid: Option<u32>,
    /// Node UID associated with the action
    pub node_uid: Option<u32>,
}

/// Action handler for tracking async operations
/// Handler for action-related operations
pub struct ActionHandler {
    client: RestClient,
}

impl ActionHandler {
    pub fn new(client: RestClient) -> Self {
        ActionHandler { client }
    }

    /// List all actions
    pub async fn list(&self) -> Result<Vec<Action>> {
        self.client.get("/v1/actions").await
    }

    /// Get specific action status
    pub async fn get(&self, action_uid: &str) -> Result<Action> {
        self.client
            .get(&format!("/v1/actions/{}", action_uid))
            .await
    }

    /// Cancel an action
    pub async fn cancel(&self, action_uid: &str) -> Result<()> {
        self.client
            .delete(&format!("/v1/actions/{}", action_uid))
            .await
    }

    /// List actions via v2 API - GET /v2/actions
    pub async fn list_v2(&self) -> Result<Vec<Action>> {
        self.client.get("/v2/actions").await
    }

    /// Get action via v2 API - GET /v2/actions/{uid}
    pub async fn get_v2(&self, action_uid: &str) -> Result<Action> {
        self.client
            .get(&format!("/v2/actions/{}", action_uid))
            .await
    }

    /// List actions for a database - GET /v1/actions/bdb/{uid}
    pub async fn list_for_bdb(&self, bdb_uid: u32) -> Result<Vec<Action>> {
        self.client
            .get(&format!("/v1/actions/bdb/{}", bdb_uid))
            .await
    }

    // Versioned sub-handlers for clearer API
    pub fn v1(&self) -> v1::ActionsV1 {
        v1::ActionsV1::new(self.client.clone())
    }

    pub fn v2(&self) -> v2::ActionsV2 {
        v2::ActionsV2::new(self.client.clone())
    }
}

pub mod v1 {
    use super::{Action, RestClient};
    use crate::error::Result;

    pub struct ActionsV1 {
        client: RestClient,
    }

    impl ActionsV1 {
        pub(crate) fn new(client: RestClient) -> Self {
            Self { client }
        }

        pub async fn list(&self) -> Result<Vec<Action>> {
            self.client.get("/v1/actions").await
        }

        pub async fn get(&self, action_uid: &str) -> Result<Action> {
            self.client
                .get(&format!("/v1/actions/{}", action_uid))
                .await
        }

        pub async fn cancel(&self, action_uid: &str) -> Result<()> {
            self.client
                .delete(&format!("/v1/actions/{}", action_uid))
                .await
        }

        pub async fn list_for_bdb(&self, bdb_uid: u32) -> Result<Vec<Action>> {
            self.client
                .get(&format!("/v1/actions/bdb/{}", bdb_uid))
                .await
        }
    }
}

pub mod v2 {
    use super::{Action, RestClient};
    use crate::error::Result;

    pub struct ActionsV2 {
        client: RestClient,
    }

    impl ActionsV2 {
        pub(crate) fn new(client: RestClient) -> Self {
            Self { client }
        }

        pub async fn list(&self) -> Result<Vec<Action>> {
            self.client.get("/v2/actions").await
        }

        pub async fn get(&self, action_uid: &str) -> Result<Action> {
            self.client
                .get(&format!("/v2/actions/{}", action_uid))
                .await
        }
    }
}