redis_enterprise/lib.rs
1//! Redis Enterprise REST API client
2//!
3//! This module provides a client for interacting with Redis Enterprise's REST API,
4//! enabling cluster management, database operations, and monitoring.
5//!
6//! # Examples
7//!
8//! ## Creating a Client
9//!
10//! ```no_run
11//! use redis_enterprise::EnterpriseClient;
12//!
13//! # async fn example() -> Result<(), Box<dyn std::error::Error>> {
14//! let client = EnterpriseClient::builder()
15//! .base_url("https://cluster.example.com:9443")
16//! .username("admin@example.com")
17//! .password("password")
18//! .insecure(false)
19//! .build()?;
20//! # Ok(())
21//! # }
22//! ```
23//!
24//! ## Working with Databases
25//!
26//! ```no_run
27//! use redis_enterprise::{EnterpriseClient, BdbHandler, CreateDatabaseRequest};
28//!
29//! # async fn example(client: EnterpriseClient) -> Result<(), Box<dyn std::error::Error>> {
30//! // List all databases
31//! let handler = BdbHandler::new(client.clone());
32//! let databases = handler.list().await?;
33//! for db in databases {
34//! println!("Database: {} ({})", db.name, db.uid);
35//! }
36//!
37//! // Create a new database
38//! let request = CreateDatabaseRequest::builder()
39//! .name("my-database")
40//! .memory_size(1024 * 1024 * 1024) // 1GB
41//! .port(12000)
42//! .replication(false)
43//! .persistence("aof")
44//! .build();
45//!
46//! let new_db = handler.create(request).await?;
47//! println!("Created database: {}", new_db.uid);
48//!
49//! // Get database stats
50//! let stats = handler.stats(new_db.uid).await?;
51//! println!("Ops/sec: {:?}", stats);
52//! # Ok(())
53//! # }
54//! ```
55//!
56//! ## Managing Nodes
57//!
58//! ```no_run
59//! use redis_enterprise::{EnterpriseClient, NodeHandler};
60//!
61//! # async fn example(client: EnterpriseClient) -> Result<(), Box<dyn std::error::Error>> {
62//! let handler = NodeHandler::new(client);
63//!
64//! // List all nodes in the cluster
65//! let nodes = handler.list().await?;
66//! for node in nodes {
67//! println!("Node {}: {:?} ({})", node.uid, node.addr, node.status);
68//! }
69//!
70//! // Get detailed node information
71//! let node_info = handler.get(1).await?;
72//! println!("Node memory: {:?} bytes", node_info.total_memory);
73//!
74//! // Check node stats
75//! let stats = handler.stats(1).await?;
76//! println!("CPU usage: {:?}", stats);
77//! # Ok(())
78//! # }
79//! ```
80//!
81//! ## Cluster Operations
82//!
83//! ```no_run
84//! use redis_enterprise::{EnterpriseClient, ClusterHandler};
85//!
86//! # async fn example(client: EnterpriseClient) -> Result<(), Box<dyn std::error::Error>> {
87//! let handler = ClusterHandler::new(client);
88//!
89//! // Get cluster information
90//! let cluster_info = handler.info().await?;
91//! println!("Cluster name: {}", cluster_info.name);
92//! println!("Nodes: {:?}", cluster_info.nodes);
93//!
94//! // Get cluster statistics
95//! let stats = handler.stats().await?;
96//! println!("Total memory: {:?}", stats);
97//!
98//! // Check license status
99//! let license = handler.license().await?;
100//! println!("License expires: {:?}", license);
101//! # Ok(())
102//! # }
103//! ```
104//!
105//! ## User Management
106//!
107//! ```no_run
108//! use redis_enterprise::{EnterpriseClient, UserHandler, CreateUserRequest};
109//!
110//! # async fn example(client: EnterpriseClient) -> Result<(), Box<dyn std::error::Error>> {
111//! let handler = UserHandler::new(client);
112//!
113//! // List all users
114//! let users = handler.list().await?;
115//! for user in users {
116//! println!("User: {} ({})", user.username, user.role);
117//! }
118//!
119//! // Create a new user
120//! let request = CreateUserRequest {
121//! username: "newuser".to_string(),
122//! password: "secure_password".to_string(),
123//! role: "db_member".to_string(),
124//! email: Some("newuser@example.com".to_string()),
125//! email_alerts: Some(true),
126//! };
127//!
128//! let new_user = handler.create(request).await?;
129//! println!("Created user: {}", new_user.uid);
130//! # Ok(())
131//! # }
132//! ```
133//!
134//! ## Monitoring and Alerts
135//!
136//! ```no_run
137//! use redis_enterprise::{EnterpriseClient, AlertHandler, StatsHandler};
138//!
139//! # async fn example(client: EnterpriseClient) -> Result<(), Box<dyn std::error::Error>> {
140//! // Check active alerts
141//! let alert_handler = AlertHandler::new(client.clone());
142//! let alerts = alert_handler.list().await?;
143//! for alert in alerts {
144//! println!("Alert: {} - {}", alert.name, alert.severity);
145//! }
146//!
147//! // Get cluster statistics
148//! let stats_handler = StatsHandler::new(client);
149//! let cluster_stats = stats_handler.cluster(None).await?;
150//! println!("Cluster stats: {:?}", cluster_stats);
151//! # Ok(())
152//! # }
153//! ```
154//!
155//! ## Active-Active Databases (CRDB)
156//!
157//! ```no_run
158//! use redis_enterprise::{EnterpriseClient, CrdbHandler, CreateCrdbRequest};
159//!
160//! # async fn example(client: EnterpriseClient) -> Result<(), Box<dyn std::error::Error>> {
161//! let handler = CrdbHandler::new(client);
162//!
163//! // List Active-Active databases
164//! let crdbs = handler.list().await?;
165//! for crdb in crdbs {
166//! println!("CRDB: {} ({})", crdb.name, crdb.guid);
167//! }
168//!
169//! // Create an Active-Active database
170//! let request = CreateCrdbRequest {
171//! name: "global-cache".to_string(),
172//! memory_size: 1024 * 1024 * 1024, // 1GB per instance
173//! instances: vec![
174//! // Define instances for each participating cluster
175//! ],
176//! encryption: Some(false),
177//! data_persistence: Some("aof".to_string()),
178//! eviction_policy: Some("allkeys-lru".to_string()),
179//! };
180//!
181//! let new_crdb = handler.create(request).await?;
182//! println!("Created CRDB: {}", new_crdb.guid);
183//! # Ok(())
184//! # }
185//! ```
186
187pub mod actions;
188pub mod alerts;
189pub mod bdb;
190pub mod bootstrap;
191pub mod client;
192pub mod cluster;
193pub mod cm_settings;
194pub mod crdb;
195pub mod crdb_tasks;
196pub mod debuginfo;
197pub mod diagnostics;
198pub mod endpoints;
199pub mod error;
200pub mod job_scheduler;
201pub mod jsonschema;
202pub mod ldap_mappings;
203pub mod license;
204pub mod logs;
205pub mod migrations;
206pub mod modules;
207pub mod nodes;
208pub mod ocsp;
209pub mod proxies;
210pub mod redis_acls;
211pub mod roles;
212pub mod services;
213pub mod shards;
214pub mod stats;
215pub mod suffixes;
216pub mod types;
217pub mod usage_report;
218pub mod users;
219
220#[cfg(test)]
221mod lib_tests;
222
223// Core client and error types
224pub use client::{EnterpriseClient, EnterpriseClientBuilder};
225pub use error::{RestError, Result};
226
227// Database management
228pub use bdb::{
229 BdbHandler, CreateDatabaseRequest, CreateDatabaseRequestBuilder, Database, ModuleConfig,
230};
231
232// Cluster management
233pub use cluster::{
234 BootstrapRequest, ClusterHandler, ClusterInfo, ClusterNode, LicenseInfo, NodeInfo,
235};
236
237// Node management
238pub use nodes::{Node, NodeActionRequest, NodeHandler, NodeStats};
239
240// User management
241pub use users::{CreateUserRequest, Role, RoleHandler, UpdateUserRequest, User, UserHandler};
242
243// Module management
244pub use modules::{Module, ModuleHandler, UploadModuleRequest};
245
246// Action tracking
247pub use actions::{Action, ActionHandler};
248
249// Logs
250pub use logs::{LogEntry, LogsHandler, LogsQuery};
251
252// Active-Active databases
253pub use crdb::{Crdb, CrdbHandler, CrdbInstance, CreateCrdbInstance, CreateCrdbRequest};
254
255// Statistics
256pub use stats::{StatsHandler, StatsInterval, StatsQuery, StatsResponse};
257
258// Alerts
259pub use alerts::{Alert, AlertHandler, AlertSettings};
260
261// Redis ACLs
262pub use redis_acls::{CreateRedisAclRequest, RedisAcl, RedisAclHandler};
263
264// Shards
265pub use shards::{Shard, ShardHandler, ShardStats};
266
267// Proxies
268pub use proxies::{Proxy, ProxyHandler, ProxyStats};
269
270// LDAP mappings
271pub use ldap_mappings::{
272 CreateLdapMappingRequest, LdapConfig, LdapMapping, LdapMappingHandler, LdapServer,
273};
274
275// OCSP
276pub use ocsp::{OcspConfig, OcspHandler, OcspStatus, OcspTestResult};
277
278// Bootstrap
279pub use bootstrap::{
280 BootstrapConfig, BootstrapHandler, BootstrapStatus, ClusterBootstrap, CredentialsBootstrap,
281 NodeBootstrap, NodePaths,
282};
283
284// Cluster Manager settings
285pub use cm_settings::{CmSettings, CmSettingsHandler};
286
287// CRDB tasks
288pub use crdb_tasks::{CrdbTask, CrdbTasksHandler, CreateCrdbTaskRequest};
289
290// Debug info
291pub use debuginfo::{DebugInfoHandler, DebugInfoRequest, DebugInfoStatus, TimeRange};
292
293// Diagnostics
294pub use diagnostics::{
295 DiagnosticReport, DiagnosticRequest, DiagnosticResult, DiagnosticSummary, DiagnosticsHandler,
296};
297
298// Endpoints
299pub use endpoints::{Endpoint, EndpointStats, EndpointsHandler};
300
301// Job scheduler
302pub use job_scheduler::{
303 CreateScheduledJobRequest, JobExecution, JobSchedulerHandler, ScheduledJob,
304};
305
306// JSON Schema
307pub use jsonschema::JsonSchemaHandler;
308
309// License
310pub use license::{License, LicenseHandler, LicenseUpdateRequest, LicenseUsage};
311
312// Migrations
313pub use migrations::{CreateMigrationRequest, Migration, MigrationEndpoint, MigrationsHandler};
314
315// Roles
316pub use roles::{BdbRole, CreateRoleRequest, RoleInfo, RolesHandler};
317
318// Services
319pub use services::{
320 NodeServiceStatus, Service, ServiceConfigRequest, ServiceStatus, ServicesHandler,
321};
322
323// Suffixes
324pub use suffixes::{CreateSuffixRequest, Suffix, SuffixesHandler};
325
326// Usage report
327pub use usage_report::{
328 DatabaseUsage, NodeUsage, UsageReport, UsageReportConfig, UsageReportHandler, UsageSummary,
329};