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

redis_cloud/connectivity/
mod.rs
