redis_cloud/connectivity/
mod.rs

1//! Network connectivity and peering operations for Pro subscriptions
2//!
3//! This module manages advanced networking features for Redis Cloud Pro subscriptions,
4//! including VPC peering, AWS Transit Gateway attachments, GCP Private Service Connect,
5//! and other cloud-native networking integrations.
6//!
7//! # Supported Connectivity Types
8//!
9//! - **VPC Peering**: Direct peering between Redis Cloud VPC and your VPC
10//! - **Transit Gateway**: AWS Transit Gateway attachments for hub-and-spoke topologies
11//! - **Private Service Connect**: GCP Private Service Connect for private endpoints
12//!
13//! # Module Organization
14//!
15//! The connectivity features are split into three specialized modules:
16//! - `vpc_peering` - VPC peering operations for AWS, GCP, and Azure
17//! - `psc` - Google Cloud Private Service Connect endpoints
18//! - `transit_gateway` - AWS Transit Gateway attachments
19
20pub mod psc;
21pub mod transit_gateway;
22pub mod vpc_peering;
23
24// Re-export handlers for convenience
25pub use psc::PscHandler;
26pub use transit_gateway::TransitGatewayHandler;
27pub use vpc_peering::VpcPeeringHandler;
28
29// Re-export types used by handlers
30pub use psc::PscEndpointUpdateRequest;
31pub use transit_gateway::{Cidr, TgwAttachmentRequest, TgwUpdateCidrsRequest};
32pub use vpc_peering::{
33    VpcPeeringCreateBaseRequest, VpcPeeringCreateRequest, VpcPeeringUpdateAwsRequest,
34    VpcPeeringUpdateRequest,
35};
36
37// For backward compatibility, provide a unified handler
38use crate::CloudClient;
39
40/// Unified connectivity handler - provides backward compatibility
41///
42/// Consider using the specific handlers directly:
43/// - `VpcPeeringHandler` for VPC peering operations
44/// - `PscHandler` for Private Service Connect operations
45/// - `TransitGatewayHandler` for Transit Gateway operations
46pub struct ConnectivityHandler {
47    pub vpc_peering: VpcPeeringHandler,
48    pub psc: PscHandler,
49    pub transit_gateway: TransitGatewayHandler,
50}
51
52impl ConnectivityHandler {
53    pub fn new(client: CloudClient) -> Self {
54        Self {
55            vpc_peering: VpcPeeringHandler::new(client.clone()),
56            psc: PscHandler::new(client.clone()),
57            transit_gateway: TransitGatewayHandler::new(client),
58        }
59    }
60
61    // VPC Peering delegation methods
62    pub async fn get_vpc_peering(
63        &self,
64        subscription_id: i32,
65    ) -> crate::Result<crate::types::TaskStateUpdate> {
66        self.vpc_peering.get(subscription_id).await
67    }
68
69    pub async fn create_vpc_peering(
70        &self,
71        subscription_id: i32,
72        request: &VpcPeeringCreateRequest,
73    ) -> crate::Result<crate::types::TaskStateUpdate> {
74        self.vpc_peering.create(subscription_id, request).await
75    }
76
77    pub async fn delete_vpc_peering(
78        &self,
79        subscription_id: i32,
80        peering_id: i32,
81    ) -> crate::Result<serde_json::Value> {
82        self.vpc_peering.delete(subscription_id, peering_id).await
83    }
84
85    pub async fn update_vpc_peering(
86        &self,
87        subscription_id: i32,
88        peering_id: i32,
89        request: &VpcPeeringUpdateAwsRequest,
90    ) -> crate::Result<crate::types::TaskStateUpdate> {
91        // VpcPeeringUpdateAwsRequest can be used as VpcPeeringCreateRequest for the update
92        let create_request = VpcPeeringCreateRequest {
93            provider: None,
94            command_type: None,
95            extra: serde_json::json!(request),
96        };
97        self.vpc_peering
98            .update(subscription_id, peering_id, &create_request)
99            .await
100    }
101
102    // PSC delegation methods
103    pub async fn get_psc_service(
104        &self,
105        subscription_id: i32,
106    ) -> crate::Result<crate::types::TaskStateUpdate> {
107        self.psc.get_service(subscription_id).await
108    }
109
110    pub async fn create_psc_service(
111        &self,
112        subscription_id: i32,
113    ) -> crate::Result<crate::types::TaskStateUpdate> {
114        self.psc.create_service(subscription_id).await
115    }
116
117    pub async fn delete_psc_service(
118        &self,
119        subscription_id: i32,
120    ) -> crate::Result<serde_json::Value> {
121        self.psc.delete_service(subscription_id).await
122    }
123
124    pub async fn create_psc_endpoint(
125        &self,
126        subscription_id: i32,
127        request: &PscEndpointUpdateRequest,
128    ) -> crate::Result<crate::types::TaskStateUpdate> {
129        self.psc.create_endpoint(subscription_id, request).await
130    }
131
132    // Transit Gateway delegation methods
133    pub async fn get_tgws(
134        &self,
135        subscription_id: i32,
136    ) -> crate::Result<crate::types::TaskStateUpdate> {
137        self.transit_gateway.get_attachments(subscription_id).await
138    }
139
140    pub async fn create_tgw_attachment(
141        &self,
142        subscription_id: i32,
143        tgw_id: &str,
144    ) -> crate::Result<crate::types::TaskStateUpdate> {
145        self.transit_gateway
146            .create_attachment_with_id(subscription_id, tgw_id)
147            .await
148    }
149
150    pub async fn delete_tgw_attachment(
151        &self,
152        subscription_id: i32,
153        attachment_id: i32,
154    ) -> crate::Result<serde_json::Value> {
155        self.transit_gateway
156            .delete_attachment(subscription_id, attachment_id.to_string())
157            .await
158    }
159
160    pub async fn update_tgw_cidrs(
161        &self,
162        subscription_id: i32,
163        attachment_id: &str,
164        request: &TgwUpdateCidrsRequest,
165    ) -> crate::Result<crate::types::TaskStateUpdate> {
166        // Convert TgwUpdateCidrsRequest to TgwAttachmentRequest
167        let attachment_request = TgwAttachmentRequest {
168            aws_account_id: None,
169            tgw_id: None,
170            cidrs: request.cidrs.as_ref().map(|cidrs| {
171                cidrs
172                    .iter()
173                    .filter_map(|c| c.cidr_address.clone())
174                    .collect()
175            }),
176            extra: serde_json::Value::Object(serde_json::Map::new()),
177        };
178        self.transit_gateway
179            .update_attachment_cidrs(
180                subscription_id,
181                attachment_id.to_string(),
182                &attachment_request,
183            )
184            .await
185    }
186
187    // Additional backward compatibility methods
188    pub async fn update_psc_service_endpoint(
189        &self,
190        subscription_id: i32,
191        endpoint_id: i32,
192        request: &PscEndpointUpdateRequest,
193    ) -> crate::Result<crate::types::TaskStateUpdate> {
194        self.psc
195            .update_endpoint(subscription_id, endpoint_id, request)
196            .await
197    }
198
199    pub async fn update_tgw_attachment_cidrs(
200        &self,
201        subscription_id: i32,
202        attachment_id: &str,
203        request: &TgwUpdateCidrsRequest,
204    ) -> crate::Result<crate::types::TaskStateUpdate> {
205        self.update_tgw_cidrs(subscription_id, attachment_id, request)
206            .await
207    }
208}
redis_cloud/connectivity/mod.rs

redis_cloud/connectivity/
mod.rs
