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

redis_cloud/connectivity/
mod.rs
