volcengine_sdk_protobuf/protobuf/
redis_instance.rs

1#[derive(serde::Serialize, serde::Deserialize)]
2#[serde(rename_all = "PascalCase")]
3#[allow(clippy::derive_partial_eq_without_eq)]
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct RedisDescribeDbInstancesReq {
6    #[prost(int64, optional, tag = "1")]
7    pub page_number: ::core::option::Option<i64>,
8    #[prost(int64, optional, tag = "2")]
9    pub page_size: ::core::option::Option<i64>,
10    #[prost(string, optional, tag = "3")]
11    pub region_id: ::core::option::Option<::prost::alloc::string::String>,
12    #[prost(string, optional, tag = "4")]
13    pub zone_id: ::core::option::Option<::prost::alloc::string::String>,
14    #[prost(string, optional, tag = "5")]
15    pub instance_id: ::core::option::Option<::prost::alloc::string::String>,
16    #[prost(string, optional, tag = "6")]
17    pub instance_name: ::core::option::Option<::prost::alloc::string::String>,
18    #[prost(int64, optional, tag = "7")]
19    pub sharded_cluster: ::core::option::Option<i64>,
20    #[prost(string, optional, tag = "8")]
21    pub status: ::core::option::Option<::prost::alloc::string::String>,
22    #[prost(string, optional, tag = "9")]
23    pub engine_version: ::core::option::Option<::prost::alloc::string::String>,
24    #[prost(string, optional, tag = "10")]
25    pub vpc_id: ::core::option::Option<::prost::alloc::string::String>,
26    #[prost(string, optional, tag = "11")]
27    pub charge_type: ::core::option::Option<::prost::alloc::string::String>,
28    #[prost(string, optional, tag = "12")]
29    pub project_name: ::core::option::Option<::prost::alloc::string::String>,
30    #[prost(string, optional, tag = "13")]
31    pub service_type: ::core::option::Option<::prost::alloc::string::String>,
32    #[prost(string, optional, tag = "14")]
33    pub data_layout: ::core::option::Option<::prost::alloc::string::String>,
34    #[prost(message, repeated, tag = "15")]
35    pub tag_filters: ::prost::alloc::vec::Vec<RedisDescribeDbInstancesTagReq>,
36}
37#[derive(serde::Serialize, serde::Deserialize)]
38#[serde(rename_all = "PascalCase")]
39#[allow(clippy::derive_partial_eq_without_eq)]
40#[derive(Clone, PartialEq, ::prost::Message)]
41pub struct RedisDescribeDbInstancesTagReq {
42    #[prost(string, optional, tag = "1")]
43    pub key: ::core::option::Option<::prost::alloc::string::String>,
44    #[prost(string, optional, tag = "2")]
45    pub value: ::core::option::Option<::prost::alloc::string::String>,
46}
47#[derive(serde::Serialize, serde::Deserialize)]
48#[serde(rename_all = "PascalCase")]
49#[allow(clippy::derive_partial_eq_without_eq)]
50#[derive(Clone, PartialEq, ::prost::Message)]
51pub struct RedisDescribeDbInstancesResp {
52    #[prost(message, optional, tag = "1")]
53    pub response_metadata: ::core::option::Option<ResponseMetadata>,
54    #[prost(message, optional, tag = "2")]
55    pub result: ::core::option::Option<RedisDescribeDbInstancesResultResp>,
56}
57#[derive(serde::Serialize, serde::Deserialize)]
58#[serde(rename_all = "PascalCase")]
59#[allow(clippy::derive_partial_eq_without_eq)]
60#[derive(Clone, PartialEq, ::prost::Message)]
61pub struct RedisDescribeDbInstancesResultResp {
62    #[prost(int64, optional, tag = "1")]
63    pub total_instances_num: ::core::option::Option<i64>,
64    #[prost(message, repeated, tag = "2")]
65    #[serde(default)]
66    pub instances: ::prost::alloc::vec::Vec<RedisDescribeDbInstancesResultInstanceResp>,
67}
68#[derive(serde::Serialize, serde::Deserialize)]
69#[serde(rename_all = "PascalCase")]
70#[allow(clippy::derive_partial_eq_without_eq)]
71#[derive(Clone, PartialEq, ::prost::Message)]
72pub struct RedisDescribeDbInstancesResultInstanceResp {
73    #[prost(string, optional, tag = "1")]
74    pub charge_type: ::core::option::Option<::prost::alloc::string::String>,
75    #[prost(string, optional, tag = "2")]
76    pub create_time: ::core::option::Option<::prost::alloc::string::String>,
77    #[prost(string, optional, tag = "3")]
78    pub deletion_protection: ::core::option::Option<::prost::alloc::string::String>,
79    #[prost(string, optional, tag = "4")]
80    pub engine_version: ::core::option::Option<::prost::alloc::string::String>,
81    #[prost(string, optional, tag = "5")]
82    pub expired_time: ::core::option::Option<::prost::alloc::string::String>,
83    #[prost(string, optional, tag = "6")]
84    pub instance_id: ::core::option::Option<::prost::alloc::string::String>,
85    #[prost(string, optional, tag = "7")]
86    pub instance_name: ::core::option::Option<::prost::alloc::string::String>,
87    #[prost(string, optional, tag = "8")]
88    pub project_name: ::core::option::Option<::prost::alloc::string::String>,
89    #[prost(string, optional, tag = "9")]
90    pub region_id: ::core::option::Option<::prost::alloc::string::String>,
91    #[prost(string, optional, tag = "10")]
92    pub status: ::core::option::Option<::prost::alloc::string::String>,
93    #[prost(string, optional, tag = "11")]
94    #[serde(rename = "MultiAZ")]
95    pub multi_az: ::core::option::Option<::prost::alloc::string::String>,
96    #[prost(string, optional, tag = "12")]
97    pub vpc_id: ::core::option::Option<::prost::alloc::string::String>,
98    #[prost(int64, optional, tag = "13")]
99    pub node_number: ::core::option::Option<i64>,
100    #[prost(int64, optional, tag = "14")]
101    pub shard_capacity: ::core::option::Option<i64>,
102    #[prost(int64, optional, tag = "15")]
103    pub shard_number: ::core::option::Option<i64>,
104    #[prost(int64, optional, tag = "16")]
105    pub sharded_cluster: ::core::option::Option<i64>,
106    #[prost(string, optional, tag = "17")]
107    pub instance_class: ::core::option::Option<::prost::alloc::string::String>,
108    #[prost(string, optional, tag = "18")]
109    pub service_type: ::core::option::Option<::prost::alloc::string::String>,
110    #[prost(string, optional, tag = "19")]
111    pub data_layout: ::core::option::Option<::prost::alloc::string::String>,
112    #[prost(string, optional, tag = "20")]
113    pub private_address: ::core::option::Option<::prost::alloc::string::String>,
114    #[prost(string, optional, tag = "21")]
115    #[serde(rename = "VIP")]
116    pub vip: ::core::option::Option<::prost::alloc::string::String>,
117    #[prost(string, optional, tag = "22")]
118    #[serde(rename = "VIPv6")]
119    pub vi_pv6: ::core::option::Option<::prost::alloc::string::String>,
120    #[prost(message, optional, tag = "23")]
121    pub capacity: ::core::option::Option<
122        RedisDescribeDbInstancesResultInstanceCapacityResp,
123    >,
124    #[prost(string, repeated, tag = "24")]
125    pub zone_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
126    #[prost(message, repeated, tag = "25")]
127    pub tags: ::prost::alloc::vec::Vec<RedisDescribeDbInstanceDetailResultTagResp>,
128}
129#[derive(serde::Serialize, serde::Deserialize)]
130#[serde(rename_all = "PascalCase")]
131#[allow(clippy::derive_partial_eq_without_eq)]
132#[derive(Clone, PartialEq, ::prost::Message)]
133pub struct RedisDescribeDbInstancesResultInstanceTagResp {
134    #[prost(string, optional, tag = "1")]
135    pub key: ::core::option::Option<::prost::alloc::string::String>,
136    #[prost(string, optional, tag = "2")]
137    pub value: ::core::option::Option<::prost::alloc::string::String>,
138}
139#[derive(serde::Serialize, serde::Deserialize)]
140#[serde(rename_all = "PascalCase")]
141#[allow(clippy::derive_partial_eq_without_eq)]
142#[derive(Clone, PartialEq, ::prost::Message)]
143pub struct RedisDescribeDbInstancesResultInstanceCapacityResp {
144    #[prost(int64, optional, tag = "1")]
145    pub used: ::core::option::Option<i64>,
146    #[prost(int64, optional, tag = "2")]
147    pub total: ::core::option::Option<i64>,
148}
149#[derive(serde::Serialize, serde::Deserialize)]
150#[serde(rename_all = "PascalCase")]
151#[allow(clippy::derive_partial_eq_without_eq)]
152#[derive(Clone, PartialEq, ::prost::Message)]
153pub struct RedisDescribeDbInstanceDetailReq {
154    #[prost(string, tag = "1")]
155    pub instance_id: ::prost::alloc::string::String,
156}
157#[derive(serde::Serialize, serde::Deserialize)]
158#[serde(rename_all = "PascalCase")]
159#[allow(clippy::derive_partial_eq_without_eq)]
160#[derive(Clone, PartialEq, ::prost::Message)]
161pub struct RedisDescribeDbInstanceDetailResp {
162    #[prost(message, optional, tag = "1")]
163    pub response_metadata: ::core::option::Option<ResponseMetadata>,
164    #[prost(message, optional, tag = "2")]
165    pub result: ::core::option::Option<RedisDescribeDbInstanceDetailResultResp>,
166}
167#[derive(serde::Serialize, serde::Deserialize)]
168#[serde(rename_all = "PascalCase")]
169#[allow(clippy::derive_partial_eq_without_eq)]
170#[derive(Clone, PartialEq, ::prost::Message)]
171pub struct RedisDescribeDbInstanceDetailResultResp {
172    #[prost(string, tag = "1")]
173    pub region_id: ::prost::alloc::string::String,
174    #[prost(string, tag = "2")]
175    pub instance_name: ::prost::alloc::string::String,
176    #[prost(string, tag = "3")]
177    pub instance_id: ::prost::alloc::string::String,
178    #[prost(string, tag = "4")]
179    pub status: ::prost::alloc::string::String,
180    #[prost(string, tag = "5")]
181    pub engine_version: ::prost::alloc::string::String,
182    #[prost(int64, tag = "6")]
183    pub sharded_cluster: i64,
184    #[prost(int64, tag = "7")]
185    pub node_number: i64,
186    #[prost(int64, tag = "8")]
187    pub shard_number: i64,
188    #[prost(int64, tag = "9")]
189    pub shard_capacity_v2: i64,
190    #[prost(string, tag = "10")]
191    pub vpc_id: ::prost::alloc::string::String,
192    #[prost(string, tag = "11")]
193    pub subnet_id: ::prost::alloc::string::String,
194    #[prost(string, tag = "12")]
195    pub create_time: ::prost::alloc::string::String,
196    #[prost(string, tag = "13")]
197    pub maintenance_time: ::prost::alloc::string::String,
198    #[prost(string, tag = "14")]
199    pub expired_time: ::prost::alloc::string::String,
200    #[prost(string, tag = "15")]
201    pub project_name: ::prost::alloc::string::String,
202    #[prost(string, tag = "16")]
203    pub deletion_protection: ::prost::alloc::string::String,
204    #[prost(string, tag = "17")]
205    pub vpc_auth_mode: ::prost::alloc::string::String,
206    #[prost(string, tag = "18")]
207    pub instance_class: ::prost::alloc::string::String,
208    #[prost(string, tag = "19")]
209    pub multi_az: ::prost::alloc::string::String,
210    #[prost(string, tag = "20")]
211    pub charge_type: ::prost::alloc::string::String,
212    #[prost(bool, tag = "21")]
213    pub auto_renew: bool,
214    #[prost(int64, tag = "22")]
215    pub max_connections: i64,
216    #[prost(string, tag = "23")]
217    pub data_layout: ::prost::alloc::string::String,
218    #[prost(message, optional, tag = "24")]
219    pub capacity: ::core::option::Option<
220        RedisDescribeDbInstanceDetailResultCapacityResp,
221    >,
222    #[prost(string, repeated, tag = "25")]
223    pub zone_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
224    #[prost(message, repeated, tag = "26")]
225    pub visit_addrs: ::prost::alloc::vec::Vec<
226        RedisDescribeDbInstanceDetailResultVisitAddrResp,
227    >,
228    #[prost(message, repeated, tag = "27")]
229    pub tags: ::prost::alloc::vec::Vec<RedisDescribeDbInstanceDetailResultTagResp>,
230}
231#[derive(serde::Serialize, serde::Deserialize)]
232#[serde(rename_all = "PascalCase")]
233#[allow(clippy::derive_partial_eq_without_eq)]
234#[derive(Clone, PartialEq, ::prost::Message)]
235pub struct RedisDescribeDbInstanceDetailResultTagResp {
236    #[prost(string, tag = "1")]
237    pub key: ::prost::alloc::string::String,
238    #[prost(string, tag = "2")]
239    pub value: ::prost::alloc::string::String,
240}
241#[derive(serde::Serialize, serde::Deserialize)]
242#[serde(rename_all = "PascalCase")]
243#[allow(clippy::derive_partial_eq_without_eq)]
244#[derive(Clone, PartialEq, ::prost::Message)]
245pub struct RedisDescribeDbInstanceDetailResultVisitAddrResp {
246    #[prost(string, tag = "1")]
247    pub port: ::prost::alloc::string::String,
248    #[prost(string, tag = "2")]
249    pub eip_id: ::prost::alloc::string::String,
250    #[prost(string, tag = "3")]
251    pub address: ::prost::alloc::string::String,
252    #[prost(string, tag = "4")]
253    pub addr_type: ::prost::alloc::string::String,
254    #[prost(string, tag = "5")]
255    pub vip: ::prost::alloc::string::String,
256    #[prost(string, tag = "6")]
257    pub vi_pv6: ::prost::alloc::string::String,
258}
259#[derive(serde::Serialize, serde::Deserialize)]
260#[serde(rename_all = "PascalCase")]
261#[allow(clippy::derive_partial_eq_without_eq)]
262#[derive(Clone, PartialEq, ::prost::Message)]
263pub struct RedisDescribeDbInstanceDetailResultCapacityResp {
264    #[prost(int64, tag = "1")]
265    pub used: i64,
266    #[prost(int64, tag = "2")]
267    pub total: i64,
268}
269#[derive(serde::Serialize, serde::Deserialize)]
270#[serde(rename_all = "PascalCase")]
271#[allow(clippy::derive_partial_eq_without_eq)]
272#[derive(Clone, PartialEq, ::prost::Message)]
273pub struct RedisCreateDbInstanceReq {
274    #[prost(string, tag = "1")]
275    pub region_id: ::prost::alloc::string::String,
276    #[prost(string, tag = "2")]
277    pub engine_version: ::prost::alloc::string::String,
278    #[prost(int64, tag = "3")]
279    pub sharded_cluster: i64,
280    #[prost(int64, tag = "4")]
281    pub shard_number: i64,
282    #[prost(int64, tag = "5")]
283    pub node_number: i64,
284    #[prost(int64, tag = "6")]
285    pub shard_capacity: i64,
286    #[prost(string, tag = "7")]
287    pub multi_az: ::prost::alloc::string::String,
288    #[prost(string, tag = "8")]
289    pub vpc_id: ::prost::alloc::string::String,
290    #[prost(string, tag = "9")]
291    pub subnet_id: ::prost::alloc::string::String,
292    #[prost(string, tag = "10")]
293    pub instance_name: ::prost::alloc::string::String,
294    #[prost(string, tag = "11")]
295    pub password: ::prost::alloc::string::String,
296    #[prost(int64, tag = "12")]
297    pub port: i64,
298    #[prost(string, tag = "13")]
299    pub project_name: ::prost::alloc::string::String,
300    #[prost(string, tag = "14")]
301    pub charge_type: ::prost::alloc::string::String,
302    #[prost(int64, tag = "15")]
303    pub purchase_months: i64,
304    #[prost(bool, tag = "16")]
305    pub auto_renew: bool,
306    #[prost(string, tag = "17")]
307    pub deletion_protection: ::prost::alloc::string::String,
308    #[prost(string, tag = "18")]
309    pub client_token: ::prost::alloc::string::String,
310    #[prost(string, repeated, tag = "19")]
311    pub allow_list_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
312    #[prost(message, repeated, tag = "20")]
313    pub configure_nodes: ::prost::alloc::vec::Vec<RedisCreateDbInstanceConfigureNodeReq>,
314    #[prost(message, repeated, tag = "21")]
315    pub tags: ::prost::alloc::vec::Vec<RedisCreateDbInstanceTagReq>,
316}
317#[derive(serde::Serialize, serde::Deserialize)]
318#[serde(rename_all = "PascalCase")]
319#[allow(clippy::derive_partial_eq_without_eq)]
320#[derive(Clone, PartialEq, ::prost::Message)]
321pub struct RedisCreateDbInstanceTagReq {
322    #[prost(string, tag = "1")]
323    pub key: ::prost::alloc::string::String,
324    #[prost(string, tag = "2")]
325    pub value: ::prost::alloc::string::String,
326}
327#[derive(serde::Serialize, serde::Deserialize)]
328#[serde(rename_all = "PascalCase")]
329#[allow(clippy::derive_partial_eq_without_eq)]
330#[derive(Clone, PartialEq, ::prost::Message)]
331pub struct RedisCreateDbInstanceConfigureNodeReq {
332    #[prost(string, tag = "1")]
333    pub az: ::prost::alloc::string::String,
334}
335#[derive(serde::Serialize, serde::Deserialize)]
336#[serde(rename_all = "PascalCase")]
337#[allow(clippy::derive_partial_eq_without_eq)]
338#[derive(Clone, PartialEq, ::prost::Message)]
339pub struct RedisCreateDbInstanceResp {
340    #[prost(message, optional, tag = "1")]
341    pub response_metadata: ::core::option::Option<ResponseMetadata>,
342    #[prost(message, optional, tag = "2")]
343    pub result: ::core::option::Option<RedisCreateDbInstanceResultResp>,
344}
345#[derive(serde::Serialize, serde::Deserialize)]
346#[serde(rename_all = "PascalCase")]
347#[allow(clippy::derive_partial_eq_without_eq)]
348#[derive(Clone, PartialEq, ::prost::Message)]
349pub struct RedisCreateDbInstanceResultResp {
350    #[prost(string, tag = "1")]
351    pub order_no: ::prost::alloc::string::String,
352    #[prost(string, tag = "2")]
353    pub instance_id: ::prost::alloc::string::String,
354}
355#[derive(serde::Serialize, serde::Deserialize)]
356#[serde(rename_all = "PascalCase")]
357#[allow(clippy::derive_partial_eq_without_eq)]
358#[derive(Clone, PartialEq, ::prost::Message)]
359pub struct RedisIncreaseDbInstanceNodeNumberReq {
360    #[prost(string, optional, tag = "1")]
361    pub instance_id: ::core::option::Option<::prost::alloc::string::String>,
362    #[prost(bool, optional, tag = "2")]
363    pub apply_immediately: ::core::option::Option<bool>,
364    #[prost(int64, optional, tag = "3")]
365    pub nodes_number_to_increase: ::core::option::Option<i64>,
366    #[prost(bool, optional, tag = "4")]
367    pub create_backup: ::core::option::Option<bool>,
368    #[prost(string, optional, tag = "5")]
369    pub backup_point_name: ::core::option::Option<::prost::alloc::string::String>,
370    #[prost(string, optional, tag = "6")]
371    pub client_token: ::core::option::Option<::prost::alloc::string::String>,
372    #[prost(message, repeated, tag = "7")]
373    pub configure_new_nodes: ::prost::alloc::vec::Vec<
374        RedisIncreaseDbInstanceNodeNumberConfigureNewNodeReq,
375    >,
376}
377#[derive(serde::Serialize, serde::Deserialize)]
378#[serde(rename_all = "PascalCase")]
379#[allow(clippy::derive_partial_eq_without_eq)]
380#[derive(Clone, PartialEq, ::prost::Message)]
381pub struct RedisIncreaseDbInstanceNodeNumberConfigureNewNodeReq {
382    #[prost(string, optional, tag = "1")]
383    pub az: ::core::option::Option<::prost::alloc::string::String>,
384}
385#[derive(serde::Serialize, serde::Deserialize)]
386#[serde(rename_all = "PascalCase")]
387#[allow(clippy::derive_partial_eq_without_eq)]
388#[derive(Clone, PartialEq, ::prost::Message)]
389pub struct RedisIncreaseDbInstanceNodeNumberResultResp {
390    #[prost(string, optional, tag = "1")]
391    pub order_no: ::core::option::Option<::prost::alloc::string::String>,
392}
393#[derive(serde::Serialize, serde::Deserialize)]
394#[serde(rename_all = "PascalCase")]
395#[allow(clippy::derive_partial_eq_without_eq)]
396#[derive(Clone, PartialEq, ::prost::Message)]
397pub struct RedisIncreaseDbInstanceNodeNumberResp {
398    #[prost(message, optional, tag = "1")]
399    pub response_metadata: ::core::option::Option<ResponseMetadata>,
400    #[prost(message, optional, tag = "2")]
401    pub result: ::core::option::Option<RedisIncreaseDbInstanceNodeNumberResultResp>,
402}
403#[derive(serde::Serialize, serde::Deserialize)]
404#[serde(rename_all = "PascalCase")]
405#[allow(clippy::derive_partial_eq_without_eq)]
406#[derive(Clone, PartialEq, ::prost::Message)]
407pub struct RedisDecreaseDbInstanceNodeNumberReq {
408    #[prost(string, optional, tag = "1")]
409    pub instance_id: ::core::option::Option<::prost::alloc::string::String>,
410    #[prost(bool, optional, tag = "2")]
411    pub apply_immediately: ::core::option::Option<bool>,
412    #[prost(int64, optional, tag = "3")]
413    pub nodes_number_to_increase: ::core::option::Option<i64>,
414    #[prost(bool, optional, tag = "4")]
415    pub create_backup: ::core::option::Option<bool>,
416    #[prost(string, optional, tag = "5")]
417    pub backup_point_name: ::core::option::Option<::prost::alloc::string::String>,
418    #[prost(string, optional, tag = "6")]
419    pub client_token: ::core::option::Option<::prost::alloc::string::String>,
420    #[prost(message, repeated, tag = "7")]
421    pub configure_new_nodes: ::prost::alloc::vec::Vec<
422        RedisIncreaseDbInstanceNodeNumberConfigureNewNodeReq,
423    >,
424}
425#[derive(serde::Serialize, serde::Deserialize)]
426#[serde(rename_all = "PascalCase")]
427#[allow(clippy::derive_partial_eq_without_eq)]
428#[derive(Clone, PartialEq, ::prost::Message)]
429pub struct RedisDecreaseDbInstanceNodeNumberResultResp {
430    #[prost(string, optional, tag = "1")]
431    pub order_no: ::core::option::Option<::prost::alloc::string::String>,
432}
433#[derive(serde::Serialize, serde::Deserialize)]
434#[serde(rename_all = "PascalCase")]
435#[allow(clippy::derive_partial_eq_without_eq)]
436#[derive(Clone, PartialEq, ::prost::Message)]
437pub struct RedisDecreaseDbInstanceNodeNumberResp {
438    #[prost(message, optional, tag = "1")]
439    pub response_metadata: ::core::option::Option<ResponseMetadata>,
440    #[prost(message, optional, tag = "2")]
441    pub result: ::core::option::Option<RedisDecreaseDbInstanceNodeNumberResultResp>,
442}
443#[derive(serde::Serialize, serde::Deserialize)]
444#[serde(rename_all = "PascalCase")]
445#[allow(clippy::derive_partial_eq_without_eq)]
446#[derive(Clone, PartialEq, ::prost::Message)]
447pub struct RedisModifyDbInstanceShardCapacityReq {
448    #[prost(string, optional, tag = "1")]
449    pub instance_id: ::core::option::Option<::prost::alloc::string::String>,
450    #[prost(bool, optional, tag = "2")]
451    pub apply_immediately: ::core::option::Option<bool>,
452    #[prost(int64, optional, tag = "3")]
453    pub shard_capacity: ::core::option::Option<i64>,
454    #[prost(bool, optional, tag = "4")]
455    pub create_backup: ::core::option::Option<bool>,
456    #[prost(string, optional, tag = "5")]
457    pub backup_point_name: ::core::option::Option<::prost::alloc::string::String>,
458    #[prost(string, optional, tag = "6")]
459    pub client_token: ::core::option::Option<::prost::alloc::string::String>,
460}
461#[derive(serde::Serialize, serde::Deserialize)]
462#[serde(rename_all = "PascalCase")]
463#[allow(clippy::derive_partial_eq_without_eq)]
464#[derive(Clone, PartialEq, ::prost::Message)]
465pub struct RedisModifyDbInstanceShardCapacityResultResp {
466    #[prost(string, optional, tag = "1")]
467    pub order_no: ::core::option::Option<::prost::alloc::string::String>,
468}
469#[derive(serde::Serialize, serde::Deserialize)]
470#[serde(rename_all = "PascalCase")]
471#[allow(clippy::derive_partial_eq_without_eq)]
472#[derive(Clone, PartialEq, ::prost::Message)]
473pub struct RedisModifyDbInstanceShardCapacityResp {
474    #[prost(message, optional, tag = "1")]
475    pub response_metadata: ::core::option::Option<ResponseMetadata>,
476    #[prost(message, optional, tag = "2")]
477    pub result: ::core::option::Option<RedisModifyDbInstanceShardCapacityResultResp>,
478}
479#[derive(serde::Serialize, serde::Deserialize)]
480#[serde(rename_all = "PascalCase")]
481#[allow(clippy::derive_partial_eq_without_eq)]
482#[derive(Clone, PartialEq, ::prost::Message)]
483pub struct RedisModifyDbInstanceShardNumberReq {
484    #[prost(string, optional, tag = "1")]
485    pub instance_id: ::core::option::Option<::prost::alloc::string::String>,
486    #[prost(bool, optional, tag = "2")]
487    pub apply_immediately: ::core::option::Option<bool>,
488    #[prost(int64, optional, tag = "3")]
489    pub shard_number: ::core::option::Option<i64>,
490    #[prost(bool, optional, tag = "4")]
491    pub create_backup: ::core::option::Option<bool>,
492    #[prost(string, optional, tag = "5")]
493    pub backup_point_name: ::core::option::Option<::prost::alloc::string::String>,
494    #[prost(string, optional, tag = "6")]
495    pub client_token: ::core::option::Option<::prost::alloc::string::String>,
496}
497#[derive(serde::Serialize, serde::Deserialize)]
498#[serde(rename_all = "PascalCase")]
499#[allow(clippy::derive_partial_eq_without_eq)]
500#[derive(Clone, PartialEq, ::prost::Message)]
501pub struct RedisModifyDbInstanceShardNumberResultResp {
502    #[prost(string, optional, tag = "1")]
503    pub order_no: ::core::option::Option<::prost::alloc::string::String>,
504}
505#[derive(serde::Serialize, serde::Deserialize)]
506#[serde(rename_all = "PascalCase")]
507#[allow(clippy::derive_partial_eq_without_eq)]
508#[derive(Clone, PartialEq, ::prost::Message)]
509pub struct RedisModifyDbInstanceShardNumberResp {
510    #[prost(message, optional, tag = "1")]
511    pub response_metadata: ::core::option::Option<ResponseMetadata>,
512    #[prost(message, optional, tag = "2")]
513    pub result: ::core::option::Option<RedisModifyDbInstanceShardNumberResultResp>,
514}
515#[derive(serde::Serialize, serde::Deserialize)]
516#[serde(rename_all = "PascalCase")]
517#[allow(clippy::derive_partial_eq_without_eq)]
518#[derive(Clone, PartialEq, ::prost::Message)]
519pub struct RedisEnableShardedClusterReq {
520    #[prost(string, optional, tag = "1")]
521    pub instance_id: ::core::option::Option<::prost::alloc::string::String>,
522    #[prost(bool, optional, tag = "2")]
523    pub apply_immediately: ::core::option::Option<bool>,
524    #[prost(int64, optional, tag = "3")]
525    pub shard_number: ::core::option::Option<i64>,
526    #[prost(int64, optional, tag = "4")]
527    pub sharded_cluster: ::core::option::Option<i64>,
528    #[prost(int64, optional, tag = "5")]
529    pub shard_capacity: ::core::option::Option<i64>,
530    #[prost(bool, optional, tag = "6")]
531    pub create_backup: ::core::option::Option<bool>,
532    #[prost(string, optional, tag = "7")]
533    pub backup_point_name: ::core::option::Option<::prost::alloc::string::String>,
534    #[prost(string, optional, tag = "8")]
535    pub client_token: ::core::option::Option<::prost::alloc::string::String>,
536}
537#[derive(serde::Serialize, serde::Deserialize)]
538#[serde(rename_all = "PascalCase")]
539#[allow(clippy::derive_partial_eq_without_eq)]
540#[derive(Clone, PartialEq, ::prost::Message)]
541pub struct RedisEnableShardedClusterResultResp {
542    #[prost(string, optional, tag = "1")]
543    pub order_no: ::core::option::Option<::prost::alloc::string::String>,
544}
545#[derive(serde::Serialize, serde::Deserialize)]
546#[serde(rename_all = "PascalCase")]
547#[allow(clippy::derive_partial_eq_without_eq)]
548#[derive(Clone, PartialEq, ::prost::Message)]
549pub struct RedisEnableShardedClusterResp {
550    #[prost(message, optional, tag = "1")]
551    pub response_metadata: ::core::option::Option<ResponseMetadata>,
552    #[prost(message, optional, tag = "2")]
553    pub result: ::core::option::Option<RedisEnableShardedClusterResultResp>,
554}
555#[derive(serde::Serialize, serde::Deserialize)]
556#[serde(rename_all = "PascalCase")]
557#[allow(clippy::derive_partial_eq_without_eq)]
558#[derive(Clone, PartialEq, ::prost::Message)]
559pub struct ResponseMetadata {
560    #[prost(string, tag = "1")]
561    pub request_id: ::prost::alloc::string::String,
562    #[prost(string, tag = "2")]
563    pub action: ::prost::alloc::string::String,
564    #[prost(string, tag = "3")]
565    pub version: ::prost::alloc::string::String,
566    #[prost(string, tag = "4")]
567    pub service: ::prost::alloc::string::String,
568    #[prost(string, tag = "5")]
569    pub region: ::prost::alloc::string::String,
570    #[prost(message, optional, tag = "6")]
571    pub error: ::core::option::Option<ResponseMetadataErr>,
572}
573#[derive(serde::Serialize, serde::Deserialize)]
574#[serde(rename_all = "PascalCase")]
575#[allow(clippy::derive_partial_eq_without_eq)]
576#[derive(Clone, PartialEq, ::prost::Message)]
577pub struct ResponseMetadataErr {
578    #[prost(int64, optional, tag = "1")]
579    pub code_n: ::core::option::Option<i64>,
580    #[prost(string, tag = "2")]
581    pub code: ::prost::alloc::string::String,
582    #[prost(string, tag = "3")]
583    pub message: ::prost::alloc::string::String,
584}
585/// Generated client implementations.
586pub mod redis_instance_client {
587    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
588    use tonic::codegen::*;
589    use tonic::codegen::http::Uri;
590    #[derive(Debug, Clone)]
591    pub struct RedisInstanceClient<T> {
592        inner: tonic::client::Grpc<T>,
593    }
594    impl RedisInstanceClient<tonic::transport::Channel> {
595        /// Attempt to create a new client by connecting to a given endpoint.
596        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
597        where
598            D: TryInto<tonic::transport::Endpoint>,
599            D::Error: Into<StdError>,
600        {
601            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
602            Ok(Self::new(conn))
603        }
604    }
605    impl<T> RedisInstanceClient<T>
606    where
607        T: tonic::client::GrpcService<tonic::body::BoxBody>,
608        T::Error: Into<StdError>,
609        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
610        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
611    {
612        pub fn new(inner: T) -> Self {
613            let inner = tonic::client::Grpc::new(inner);
614            Self { inner }
615        }
616        pub fn with_origin(inner: T, origin: Uri) -> Self {
617            let inner = tonic::client::Grpc::with_origin(inner, origin);
618            Self { inner }
619        }
620        pub fn with_interceptor<F>(
621            inner: T,
622            interceptor: F,
623        ) -> RedisInstanceClient<InterceptedService<T, F>>
624        where
625            F: tonic::service::Interceptor,
626            T::ResponseBody: Default,
627            T: tonic::codegen::Service<
628                http::Request<tonic::body::BoxBody>,
629                Response = http::Response<
630                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
631                >,
632            >,
633            <T as tonic::codegen::Service<
634                http::Request<tonic::body::BoxBody>,
635            >>::Error: Into<StdError> + Send + Sync,
636        {
637            RedisInstanceClient::new(InterceptedService::new(inner, interceptor))
638        }
639        /// Compress requests with the given encoding.
640        ///
641        /// This requires the server to support it otherwise it might respond with an
642        /// error.
643        #[must_use]
644        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
645            self.inner = self.inner.send_compressed(encoding);
646            self
647        }
648        /// Enable decompressing responses.
649        #[must_use]
650        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
651            self.inner = self.inner.accept_compressed(encoding);
652            self
653        }
654        /// Limits the maximum size of a decoded message.
655        ///
656        /// Default: `4MB`
657        #[must_use]
658        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
659            self.inner = self.inner.max_decoding_message_size(limit);
660            self
661        }
662        /// Limits the maximum size of an encoded message.
663        ///
664        /// Default: `usize::MAX`
665        #[must_use]
666        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
667            self.inner = self.inner.max_encoding_message_size(limit);
668            self
669        }
670        /// DescribeDBInstances
671        pub async fn redis_describe_db_instances(
672            &mut self,
673            request: impl tonic::IntoRequest<super::RedisDescribeDbInstancesReq>,
674        ) -> std::result::Result<
675            tonic::Response<super::RedisDescribeDbInstancesResp>,
676            tonic::Status,
677        > {
678            self.inner
679                .ready()
680                .await
681                .map_err(|e| {
682                    tonic::Status::new(
683                        tonic::Code::Unknown,
684                        format!("Service was not ready: {}", e.into()),
685                    )
686                })?;
687            let codec = tonic::codec::ProstCodec::default();
688            let path = http::uri::PathAndQuery::from_static(
689                "/redis_instance.RedisInstance/RedisDescribeDBInstances",
690            );
691            let mut req = request.into_request();
692            req.extensions_mut()
693                .insert(
694                    GrpcMethod::new(
695                        "redis_instance.RedisInstance",
696                        "RedisDescribeDBInstances",
697                    ),
698                );
699            self.inner.unary(req, path, codec).await
700        }
701        /// CreateDBInstance
702        pub async fn redis_create_db_instance(
703            &mut self,
704            request: impl tonic::IntoRequest<super::RedisCreateDbInstanceReq>,
705        ) -> std::result::Result<
706            tonic::Response<super::RedisCreateDbInstanceResp>,
707            tonic::Status,
708        > {
709            self.inner
710                .ready()
711                .await
712                .map_err(|e| {
713                    tonic::Status::new(
714                        tonic::Code::Unknown,
715                        format!("Service was not ready: {}", e.into()),
716                    )
717                })?;
718            let codec = tonic::codec::ProstCodec::default();
719            let path = http::uri::PathAndQuery::from_static(
720                "/redis_instance.RedisInstance/RedisCreateDBInstance",
721            );
722            let mut req = request.into_request();
723            req.extensions_mut()
724                .insert(
725                    GrpcMethod::new(
726                        "redis_instance.RedisInstance",
727                        "RedisCreateDBInstance",
728                    ),
729                );
730            self.inner.unary(req, path, codec).await
731        }
732        /// DescribeDBInstanceDetail
733        pub async fn redis_describe_db_instance_detail(
734            &mut self,
735            request: impl tonic::IntoRequest<super::RedisDescribeDbInstanceDetailReq>,
736        ) -> std::result::Result<
737            tonic::Response<super::RedisDescribeDbInstanceDetailResp>,
738            tonic::Status,
739        > {
740            self.inner
741                .ready()
742                .await
743                .map_err(|e| {
744                    tonic::Status::new(
745                        tonic::Code::Unknown,
746                        format!("Service was not ready: {}", e.into()),
747                    )
748                })?;
749            let codec = tonic::codec::ProstCodec::default();
750            let path = http::uri::PathAndQuery::from_static(
751                "/redis_instance.RedisInstance/RedisDescribeDBInstanceDetail",
752            );
753            let mut req = request.into_request();
754            req.extensions_mut()
755                .insert(
756                    GrpcMethod::new(
757                        "redis_instance.RedisInstance",
758                        "RedisDescribeDBInstanceDetail",
759                    ),
760                );
761            self.inner.unary(req, path, codec).await
762        }
763        /// IncreaseDBInstanceNodeNumber
764        pub async fn redis_increase_db_instance_node_number(
765            &mut self,
766            request: impl tonic::IntoRequest<super::RedisIncreaseDbInstanceNodeNumberReq>,
767        ) -> std::result::Result<
768            tonic::Response<super::RedisIncreaseDbInstanceNodeNumberResp>,
769            tonic::Status,
770        > {
771            self.inner
772                .ready()
773                .await
774                .map_err(|e| {
775                    tonic::Status::new(
776                        tonic::Code::Unknown,
777                        format!("Service was not ready: {}", e.into()),
778                    )
779                })?;
780            let codec = tonic::codec::ProstCodec::default();
781            let path = http::uri::PathAndQuery::from_static(
782                "/redis_instance.RedisInstance/RedisIncreaseDBInstanceNodeNumber",
783            );
784            let mut req = request.into_request();
785            req.extensions_mut()
786                .insert(
787                    GrpcMethod::new(
788                        "redis_instance.RedisInstance",
789                        "RedisIncreaseDBInstanceNodeNumber",
790                    ),
791                );
792            self.inner.unary(req, path, codec).await
793        }
794        /// DecreaseDBInstanceNodeNumber
795        pub async fn redis_decrease_db_instance_node_number(
796            &mut self,
797            request: impl tonic::IntoRequest<super::RedisDecreaseDbInstanceNodeNumberReq>,
798        ) -> std::result::Result<
799            tonic::Response<super::RedisDecreaseDbInstanceNodeNumberResp>,
800            tonic::Status,
801        > {
802            self.inner
803                .ready()
804                .await
805                .map_err(|e| {
806                    tonic::Status::new(
807                        tonic::Code::Unknown,
808                        format!("Service was not ready: {}", e.into()),
809                    )
810                })?;
811            let codec = tonic::codec::ProstCodec::default();
812            let path = http::uri::PathAndQuery::from_static(
813                "/redis_instance.RedisInstance/RedisDecreaseDBInstanceNodeNumber",
814            );
815            let mut req = request.into_request();
816            req.extensions_mut()
817                .insert(
818                    GrpcMethod::new(
819                        "redis_instance.RedisInstance",
820                        "RedisDecreaseDBInstanceNodeNumber",
821                    ),
822                );
823            self.inner.unary(req, path, codec).await
824        }
825        /// ModifyDBInstanceShardCapacity
826        pub async fn redis_modify_db_instance_shard_capacity(
827            &mut self,
828            request: impl tonic::IntoRequest<
829                super::RedisModifyDbInstanceShardCapacityReq,
830            >,
831        ) -> std::result::Result<
832            tonic::Response<super::RedisModifyDbInstanceShardCapacityResp>,
833            tonic::Status,
834        > {
835            self.inner
836                .ready()
837                .await
838                .map_err(|e| {
839                    tonic::Status::new(
840                        tonic::Code::Unknown,
841                        format!("Service was not ready: {}", e.into()),
842                    )
843                })?;
844            let codec = tonic::codec::ProstCodec::default();
845            let path = http::uri::PathAndQuery::from_static(
846                "/redis_instance.RedisInstance/RedisModifyDBInstanceShardCapacity",
847            );
848            let mut req = request.into_request();
849            req.extensions_mut()
850                .insert(
851                    GrpcMethod::new(
852                        "redis_instance.RedisInstance",
853                        "RedisModifyDBInstanceShardCapacity",
854                    ),
855                );
856            self.inner.unary(req, path, codec).await
857        }
858        /// ModifyDBInstanceShardNumber
859        pub async fn redis_modify_db_instance_shard_number(
860            &mut self,
861            request: impl tonic::IntoRequest<super::RedisModifyDbInstanceShardNumberReq>,
862        ) -> std::result::Result<
863            tonic::Response<super::RedisModifyDbInstanceShardNumberResp>,
864            tonic::Status,
865        > {
866            self.inner
867                .ready()
868                .await
869                .map_err(|e| {
870                    tonic::Status::new(
871                        tonic::Code::Unknown,
872                        format!("Service was not ready: {}", e.into()),
873                    )
874                })?;
875            let codec = tonic::codec::ProstCodec::default();
876            let path = http::uri::PathAndQuery::from_static(
877                "/redis_instance.RedisInstance/RedisModifyDBInstanceShardNumber",
878            );
879            let mut req = request.into_request();
880            req.extensions_mut()
881                .insert(
882                    GrpcMethod::new(
883                        "redis_instance.RedisInstance",
884                        "RedisModifyDBInstanceShardNumber",
885                    ),
886                );
887            self.inner.unary(req, path, codec).await
888        }
889        /// EnableShardedCluster
890        pub async fn redis_enable_sharded_cluster(
891            &mut self,
892            request: impl tonic::IntoRequest<super::RedisEnableShardedClusterReq>,
893        ) -> std::result::Result<
894            tonic::Response<super::RedisEnableShardedClusterResp>,
895            tonic::Status,
896        > {
897            self.inner
898                .ready()
899                .await
900                .map_err(|e| {
901                    tonic::Status::new(
902                        tonic::Code::Unknown,
903                        format!("Service was not ready: {}", e.into()),
904                    )
905                })?;
906            let codec = tonic::codec::ProstCodec::default();
907            let path = http::uri::PathAndQuery::from_static(
908                "/redis_instance.RedisInstance/RedisEnableShardedCluster",
909            );
910            let mut req = request.into_request();
911            req.extensions_mut()
912                .insert(
913                    GrpcMethod::new(
914                        "redis_instance.RedisInstance",
915                        "RedisEnableShardedCluster",
916                    ),
917                );
918            self.inner.unary(req, path, codec).await
919        }
920    }
921}
922/// Generated server implementations.
923pub mod redis_instance_server {
924    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
925    use tonic::codegen::*;
926    /// Generated trait containing gRPC methods that should be implemented for use with RedisInstanceServer.
927    #[async_trait]
928    pub trait RedisInstance: Send + Sync + 'static {
929        /// DescribeDBInstances
930        async fn redis_describe_db_instances(
931            &self,
932            request: tonic::Request<super::RedisDescribeDbInstancesReq>,
933        ) -> std::result::Result<
934            tonic::Response<super::RedisDescribeDbInstancesResp>,
935            tonic::Status,
936        >;
937        /// CreateDBInstance
938        async fn redis_create_db_instance(
939            &self,
940            request: tonic::Request<super::RedisCreateDbInstanceReq>,
941        ) -> std::result::Result<
942            tonic::Response<super::RedisCreateDbInstanceResp>,
943            tonic::Status,
944        >;
945        /// DescribeDBInstanceDetail
946        async fn redis_describe_db_instance_detail(
947            &self,
948            request: tonic::Request<super::RedisDescribeDbInstanceDetailReq>,
949        ) -> std::result::Result<
950            tonic::Response<super::RedisDescribeDbInstanceDetailResp>,
951            tonic::Status,
952        >;
953        /// IncreaseDBInstanceNodeNumber
954        async fn redis_increase_db_instance_node_number(
955            &self,
956            request: tonic::Request<super::RedisIncreaseDbInstanceNodeNumberReq>,
957        ) -> std::result::Result<
958            tonic::Response<super::RedisIncreaseDbInstanceNodeNumberResp>,
959            tonic::Status,
960        >;
961        /// DecreaseDBInstanceNodeNumber
962        async fn redis_decrease_db_instance_node_number(
963            &self,
964            request: tonic::Request<super::RedisDecreaseDbInstanceNodeNumberReq>,
965        ) -> std::result::Result<
966            tonic::Response<super::RedisDecreaseDbInstanceNodeNumberResp>,
967            tonic::Status,
968        >;
969        /// ModifyDBInstanceShardCapacity
970        async fn redis_modify_db_instance_shard_capacity(
971            &self,
972            request: tonic::Request<super::RedisModifyDbInstanceShardCapacityReq>,
973        ) -> std::result::Result<
974            tonic::Response<super::RedisModifyDbInstanceShardCapacityResp>,
975            tonic::Status,
976        >;
977        /// ModifyDBInstanceShardNumber
978        async fn redis_modify_db_instance_shard_number(
979            &self,
980            request: tonic::Request<super::RedisModifyDbInstanceShardNumberReq>,
981        ) -> std::result::Result<
982            tonic::Response<super::RedisModifyDbInstanceShardNumberResp>,
983            tonic::Status,
984        >;
985        /// EnableShardedCluster
986        async fn redis_enable_sharded_cluster(
987            &self,
988            request: tonic::Request<super::RedisEnableShardedClusterReq>,
989        ) -> std::result::Result<
990            tonic::Response<super::RedisEnableShardedClusterResp>,
991            tonic::Status,
992        >;
993    }
994    #[derive(Debug)]
995    pub struct RedisInstanceServer<T: RedisInstance> {
996        inner: _Inner<T>,
997        accept_compression_encodings: EnabledCompressionEncodings,
998        send_compression_encodings: EnabledCompressionEncodings,
999        max_decoding_message_size: Option<usize>,
1000        max_encoding_message_size: Option<usize>,
1001    }
1002    struct _Inner<T>(Arc<T>);
1003    impl<T: RedisInstance> RedisInstanceServer<T> {
1004        pub fn new(inner: T) -> Self {
1005            Self::from_arc(Arc::new(inner))
1006        }
1007        pub fn from_arc(inner: Arc<T>) -> Self {
1008            let inner = _Inner(inner);
1009            Self {
1010                inner,
1011                accept_compression_encodings: Default::default(),
1012                send_compression_encodings: Default::default(),
1013                max_decoding_message_size: None,
1014                max_encoding_message_size: None,
1015            }
1016        }
1017        pub fn with_interceptor<F>(
1018            inner: T,
1019            interceptor: F,
1020        ) -> InterceptedService<Self, F>
1021        where
1022            F: tonic::service::Interceptor,
1023        {
1024            InterceptedService::new(Self::new(inner), interceptor)
1025        }
1026        /// Enable decompressing requests with the given encoding.
1027        #[must_use]
1028        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1029            self.accept_compression_encodings.enable(encoding);
1030            self
1031        }
1032        /// Compress responses with the given encoding, if the client supports it.
1033        #[must_use]
1034        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1035            self.send_compression_encodings.enable(encoding);
1036            self
1037        }
1038        /// Limits the maximum size of a decoded message.
1039        ///
1040        /// Default: `4MB`
1041        #[must_use]
1042        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1043            self.max_decoding_message_size = Some(limit);
1044            self
1045        }
1046        /// Limits the maximum size of an encoded message.
1047        ///
1048        /// Default: `usize::MAX`
1049        #[must_use]
1050        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1051            self.max_encoding_message_size = Some(limit);
1052            self
1053        }
1054    }
1055    impl<T, B> tonic::codegen::Service<http::Request<B>> for RedisInstanceServer<T>
1056    where
1057        T: RedisInstance,
1058        B: Body + Send + 'static,
1059        B::Error: Into<StdError> + Send + 'static,
1060    {
1061        type Response = http::Response<tonic::body::BoxBody>;
1062        type Error = std::convert::Infallible;
1063        type Future = BoxFuture<Self::Response, Self::Error>;
1064        fn poll_ready(
1065            &mut self,
1066            _cx: &mut Context<'_>,
1067        ) -> Poll<std::result::Result<(), Self::Error>> {
1068            Poll::Ready(Ok(()))
1069        }
1070        fn call(&mut self, req: http::Request<B>) -> Self::Future {
1071            let inner = self.inner.clone();
1072            match req.uri().path() {
1073                "/redis_instance.RedisInstance/RedisDescribeDBInstances" => {
1074                    #[allow(non_camel_case_types)]
1075                    struct RedisDescribeDBInstancesSvc<T: RedisInstance>(pub Arc<T>);
1076                    impl<
1077                        T: RedisInstance,
1078                    > tonic::server::UnaryService<super::RedisDescribeDbInstancesReq>
1079                    for RedisDescribeDBInstancesSvc<T> {
1080                        type Response = super::RedisDescribeDbInstancesResp;
1081                        type Future = BoxFuture<
1082                            tonic::Response<Self::Response>,
1083                            tonic::Status,
1084                        >;
1085                        fn call(
1086                            &mut self,
1087                            request: tonic::Request<super::RedisDescribeDbInstancesReq>,
1088                        ) -> Self::Future {
1089                            let inner = Arc::clone(&self.0);
1090                            let fut = async move {
1091                                (*inner).redis_describe_db_instances(request).await
1092                            };
1093                            Box::pin(fut)
1094                        }
1095                    }
1096                    let accept_compression_encodings = self.accept_compression_encodings;
1097                    let send_compression_encodings = self.send_compression_encodings;
1098                    let max_decoding_message_size = self.max_decoding_message_size;
1099                    let max_encoding_message_size = self.max_encoding_message_size;
1100                    let inner = self.inner.clone();
1101                    let fut = async move {
1102                        let inner = inner.0;
1103                        let method = RedisDescribeDBInstancesSvc(inner);
1104                        let codec = tonic::codec::ProstCodec::default();
1105                        let mut grpc = tonic::server::Grpc::new(codec)
1106                            .apply_compression_config(
1107                                accept_compression_encodings,
1108                                send_compression_encodings,
1109                            )
1110                            .apply_max_message_size_config(
1111                                max_decoding_message_size,
1112                                max_encoding_message_size,
1113                            );
1114                        let res = grpc.unary(method, req).await;
1115                        Ok(res)
1116                    };
1117                    Box::pin(fut)
1118                }
1119                "/redis_instance.RedisInstance/RedisCreateDBInstance" => {
1120                    #[allow(non_camel_case_types)]
1121                    struct RedisCreateDBInstanceSvc<T: RedisInstance>(pub Arc<T>);
1122                    impl<
1123                        T: RedisInstance,
1124                    > tonic::server::UnaryService<super::RedisCreateDbInstanceReq>
1125                    for RedisCreateDBInstanceSvc<T> {
1126                        type Response = super::RedisCreateDbInstanceResp;
1127                        type Future = BoxFuture<
1128                            tonic::Response<Self::Response>,
1129                            tonic::Status,
1130                        >;
1131                        fn call(
1132                            &mut self,
1133                            request: tonic::Request<super::RedisCreateDbInstanceReq>,
1134                        ) -> Self::Future {
1135                            let inner = Arc::clone(&self.0);
1136                            let fut = async move {
1137                                (*inner).redis_create_db_instance(request).await
1138                            };
1139                            Box::pin(fut)
1140                        }
1141                    }
1142                    let accept_compression_encodings = self.accept_compression_encodings;
1143                    let send_compression_encodings = self.send_compression_encodings;
1144                    let max_decoding_message_size = self.max_decoding_message_size;
1145                    let max_encoding_message_size = self.max_encoding_message_size;
1146                    let inner = self.inner.clone();
1147                    let fut = async move {
1148                        let inner = inner.0;
1149                        let method = RedisCreateDBInstanceSvc(inner);
1150                        let codec = tonic::codec::ProstCodec::default();
1151                        let mut grpc = tonic::server::Grpc::new(codec)
1152                            .apply_compression_config(
1153                                accept_compression_encodings,
1154                                send_compression_encodings,
1155                            )
1156                            .apply_max_message_size_config(
1157                                max_decoding_message_size,
1158                                max_encoding_message_size,
1159                            );
1160                        let res = grpc.unary(method, req).await;
1161                        Ok(res)
1162                    };
1163                    Box::pin(fut)
1164                }
1165                "/redis_instance.RedisInstance/RedisDescribeDBInstanceDetail" => {
1166                    #[allow(non_camel_case_types)]
1167                    struct RedisDescribeDBInstanceDetailSvc<T: RedisInstance>(
1168                        pub Arc<T>,
1169                    );
1170                    impl<
1171                        T: RedisInstance,
1172                    > tonic::server::UnaryService<
1173                        super::RedisDescribeDbInstanceDetailReq,
1174                    > for RedisDescribeDBInstanceDetailSvc<T> {
1175                        type Response = super::RedisDescribeDbInstanceDetailResp;
1176                        type Future = BoxFuture<
1177                            tonic::Response<Self::Response>,
1178                            tonic::Status,
1179                        >;
1180                        fn call(
1181                            &mut self,
1182                            request: tonic::Request<
1183                                super::RedisDescribeDbInstanceDetailReq,
1184                            >,
1185                        ) -> Self::Future {
1186                            let inner = Arc::clone(&self.0);
1187                            let fut = async move {
1188                                (*inner).redis_describe_db_instance_detail(request).await
1189                            };
1190                            Box::pin(fut)
1191                        }
1192                    }
1193                    let accept_compression_encodings = self.accept_compression_encodings;
1194                    let send_compression_encodings = self.send_compression_encodings;
1195                    let max_decoding_message_size = self.max_decoding_message_size;
1196                    let max_encoding_message_size = self.max_encoding_message_size;
1197                    let inner = self.inner.clone();
1198                    let fut = async move {
1199                        let inner = inner.0;
1200                        let method = RedisDescribeDBInstanceDetailSvc(inner);
1201                        let codec = tonic::codec::ProstCodec::default();
1202                        let mut grpc = tonic::server::Grpc::new(codec)
1203                            .apply_compression_config(
1204                                accept_compression_encodings,
1205                                send_compression_encodings,
1206                            )
1207                            .apply_max_message_size_config(
1208                                max_decoding_message_size,
1209                                max_encoding_message_size,
1210                            );
1211                        let res = grpc.unary(method, req).await;
1212                        Ok(res)
1213                    };
1214                    Box::pin(fut)
1215                }
1216                "/redis_instance.RedisInstance/RedisIncreaseDBInstanceNodeNumber" => {
1217                    #[allow(non_camel_case_types)]
1218                    struct RedisIncreaseDBInstanceNodeNumberSvc<T: RedisInstance>(
1219                        pub Arc<T>,
1220                    );
1221                    impl<
1222                        T: RedisInstance,
1223                    > tonic::server::UnaryService<
1224                        super::RedisIncreaseDbInstanceNodeNumberReq,
1225                    > for RedisIncreaseDBInstanceNodeNumberSvc<T> {
1226                        type Response = super::RedisIncreaseDbInstanceNodeNumberResp;
1227                        type Future = BoxFuture<
1228                            tonic::Response<Self::Response>,
1229                            tonic::Status,
1230                        >;
1231                        fn call(
1232                            &mut self,
1233                            request: tonic::Request<
1234                                super::RedisIncreaseDbInstanceNodeNumberReq,
1235                            >,
1236                        ) -> Self::Future {
1237                            let inner = Arc::clone(&self.0);
1238                            let fut = async move {
1239                                (*inner)
1240                                    .redis_increase_db_instance_node_number(request)
1241                                    .await
1242                            };
1243                            Box::pin(fut)
1244                        }
1245                    }
1246                    let accept_compression_encodings = self.accept_compression_encodings;
1247                    let send_compression_encodings = self.send_compression_encodings;
1248                    let max_decoding_message_size = self.max_decoding_message_size;
1249                    let max_encoding_message_size = self.max_encoding_message_size;
1250                    let inner = self.inner.clone();
1251                    let fut = async move {
1252                        let inner = inner.0;
1253                        let method = RedisIncreaseDBInstanceNodeNumberSvc(inner);
1254                        let codec = tonic::codec::ProstCodec::default();
1255                        let mut grpc = tonic::server::Grpc::new(codec)
1256                            .apply_compression_config(
1257                                accept_compression_encodings,
1258                                send_compression_encodings,
1259                            )
1260                            .apply_max_message_size_config(
1261                                max_decoding_message_size,
1262                                max_encoding_message_size,
1263                            );
1264                        let res = grpc.unary(method, req).await;
1265                        Ok(res)
1266                    };
1267                    Box::pin(fut)
1268                }
1269                "/redis_instance.RedisInstance/RedisDecreaseDBInstanceNodeNumber" => {
1270                    #[allow(non_camel_case_types)]
1271                    struct RedisDecreaseDBInstanceNodeNumberSvc<T: RedisInstance>(
1272                        pub Arc<T>,
1273                    );
1274                    impl<
1275                        T: RedisInstance,
1276                    > tonic::server::UnaryService<
1277                        super::RedisDecreaseDbInstanceNodeNumberReq,
1278                    > for RedisDecreaseDBInstanceNodeNumberSvc<T> {
1279                        type Response = super::RedisDecreaseDbInstanceNodeNumberResp;
1280                        type Future = BoxFuture<
1281                            tonic::Response<Self::Response>,
1282                            tonic::Status,
1283                        >;
1284                        fn call(
1285                            &mut self,
1286                            request: tonic::Request<
1287                                super::RedisDecreaseDbInstanceNodeNumberReq,
1288                            >,
1289                        ) -> Self::Future {
1290                            let inner = Arc::clone(&self.0);
1291                            let fut = async move {
1292                                (*inner)
1293                                    .redis_decrease_db_instance_node_number(request)
1294                                    .await
1295                            };
1296                            Box::pin(fut)
1297                        }
1298                    }
1299                    let accept_compression_encodings = self.accept_compression_encodings;
1300                    let send_compression_encodings = self.send_compression_encodings;
1301                    let max_decoding_message_size = self.max_decoding_message_size;
1302                    let max_encoding_message_size = self.max_encoding_message_size;
1303                    let inner = self.inner.clone();
1304                    let fut = async move {
1305                        let inner = inner.0;
1306                        let method = RedisDecreaseDBInstanceNodeNumberSvc(inner);
1307                        let codec = tonic::codec::ProstCodec::default();
1308                        let mut grpc = tonic::server::Grpc::new(codec)
1309                            .apply_compression_config(
1310                                accept_compression_encodings,
1311                                send_compression_encodings,
1312                            )
1313                            .apply_max_message_size_config(
1314                                max_decoding_message_size,
1315                                max_encoding_message_size,
1316                            );
1317                        let res = grpc.unary(method, req).await;
1318                        Ok(res)
1319                    };
1320                    Box::pin(fut)
1321                }
1322                "/redis_instance.RedisInstance/RedisModifyDBInstanceShardCapacity" => {
1323                    #[allow(non_camel_case_types)]
1324                    struct RedisModifyDBInstanceShardCapacitySvc<T: RedisInstance>(
1325                        pub Arc<T>,
1326                    );
1327                    impl<
1328                        T: RedisInstance,
1329                    > tonic::server::UnaryService<
1330                        super::RedisModifyDbInstanceShardCapacityReq,
1331                    > for RedisModifyDBInstanceShardCapacitySvc<T> {
1332                        type Response = super::RedisModifyDbInstanceShardCapacityResp;
1333                        type Future = BoxFuture<
1334                            tonic::Response<Self::Response>,
1335                            tonic::Status,
1336                        >;
1337                        fn call(
1338                            &mut self,
1339                            request: tonic::Request<
1340                                super::RedisModifyDbInstanceShardCapacityReq,
1341                            >,
1342                        ) -> Self::Future {
1343                            let inner = Arc::clone(&self.0);
1344                            let fut = async move {
1345                                (*inner)
1346                                    .redis_modify_db_instance_shard_capacity(request)
1347                                    .await
1348                            };
1349                            Box::pin(fut)
1350                        }
1351                    }
1352                    let accept_compression_encodings = self.accept_compression_encodings;
1353                    let send_compression_encodings = self.send_compression_encodings;
1354                    let max_decoding_message_size = self.max_decoding_message_size;
1355                    let max_encoding_message_size = self.max_encoding_message_size;
1356                    let inner = self.inner.clone();
1357                    let fut = async move {
1358                        let inner = inner.0;
1359                        let method = RedisModifyDBInstanceShardCapacitySvc(inner);
1360                        let codec = tonic::codec::ProstCodec::default();
1361                        let mut grpc = tonic::server::Grpc::new(codec)
1362                            .apply_compression_config(
1363                                accept_compression_encodings,
1364                                send_compression_encodings,
1365                            )
1366                            .apply_max_message_size_config(
1367                                max_decoding_message_size,
1368                                max_encoding_message_size,
1369                            );
1370                        let res = grpc.unary(method, req).await;
1371                        Ok(res)
1372                    };
1373                    Box::pin(fut)
1374                }
1375                "/redis_instance.RedisInstance/RedisModifyDBInstanceShardNumber" => {
1376                    #[allow(non_camel_case_types)]
1377                    struct RedisModifyDBInstanceShardNumberSvc<T: RedisInstance>(
1378                        pub Arc<T>,
1379                    );
1380                    impl<
1381                        T: RedisInstance,
1382                    > tonic::server::UnaryService<
1383                        super::RedisModifyDbInstanceShardNumberReq,
1384                    > for RedisModifyDBInstanceShardNumberSvc<T> {
1385                        type Response = super::RedisModifyDbInstanceShardNumberResp;
1386                        type Future = BoxFuture<
1387                            tonic::Response<Self::Response>,
1388                            tonic::Status,
1389                        >;
1390                        fn call(
1391                            &mut self,
1392                            request: tonic::Request<
1393                                super::RedisModifyDbInstanceShardNumberReq,
1394                            >,
1395                        ) -> Self::Future {
1396                            let inner = Arc::clone(&self.0);
1397                            let fut = async move {
1398                                (*inner)
1399                                    .redis_modify_db_instance_shard_number(request)
1400                                    .await
1401                            };
1402                            Box::pin(fut)
1403                        }
1404                    }
1405                    let accept_compression_encodings = self.accept_compression_encodings;
1406                    let send_compression_encodings = self.send_compression_encodings;
1407                    let max_decoding_message_size = self.max_decoding_message_size;
1408                    let max_encoding_message_size = self.max_encoding_message_size;
1409                    let inner = self.inner.clone();
1410                    let fut = async move {
1411                        let inner = inner.0;
1412                        let method = RedisModifyDBInstanceShardNumberSvc(inner);
1413                        let codec = tonic::codec::ProstCodec::default();
1414                        let mut grpc = tonic::server::Grpc::new(codec)
1415                            .apply_compression_config(
1416                                accept_compression_encodings,
1417                                send_compression_encodings,
1418                            )
1419                            .apply_max_message_size_config(
1420                                max_decoding_message_size,
1421                                max_encoding_message_size,
1422                            );
1423                        let res = grpc.unary(method, req).await;
1424                        Ok(res)
1425                    };
1426                    Box::pin(fut)
1427                }
1428                "/redis_instance.RedisInstance/RedisEnableShardedCluster" => {
1429                    #[allow(non_camel_case_types)]
1430                    struct RedisEnableShardedClusterSvc<T: RedisInstance>(pub Arc<T>);
1431                    impl<
1432                        T: RedisInstance,
1433                    > tonic::server::UnaryService<super::RedisEnableShardedClusterReq>
1434                    for RedisEnableShardedClusterSvc<T> {
1435                        type Response = super::RedisEnableShardedClusterResp;
1436                        type Future = BoxFuture<
1437                            tonic::Response<Self::Response>,
1438                            tonic::Status,
1439                        >;
1440                        fn call(
1441                            &mut self,
1442                            request: tonic::Request<super::RedisEnableShardedClusterReq>,
1443                        ) -> Self::Future {
1444                            let inner = Arc::clone(&self.0);
1445                            let fut = async move {
1446                                (*inner).redis_enable_sharded_cluster(request).await
1447                            };
1448                            Box::pin(fut)
1449                        }
1450                    }
1451                    let accept_compression_encodings = self.accept_compression_encodings;
1452                    let send_compression_encodings = self.send_compression_encodings;
1453                    let max_decoding_message_size = self.max_decoding_message_size;
1454                    let max_encoding_message_size = self.max_encoding_message_size;
1455                    let inner = self.inner.clone();
1456                    let fut = async move {
1457                        let inner = inner.0;
1458                        let method = RedisEnableShardedClusterSvc(inner);
1459                        let codec = tonic::codec::ProstCodec::default();
1460                        let mut grpc = tonic::server::Grpc::new(codec)
1461                            .apply_compression_config(
1462                                accept_compression_encodings,
1463                                send_compression_encodings,
1464                            )
1465                            .apply_max_message_size_config(
1466                                max_decoding_message_size,
1467                                max_encoding_message_size,
1468                            );
1469                        let res = grpc.unary(method, req).await;
1470                        Ok(res)
1471                    };
1472                    Box::pin(fut)
1473                }
1474                _ => {
1475                    Box::pin(async move {
1476                        Ok(
1477                            http::Response::builder()
1478                                .status(200)
1479                                .header("grpc-status", "12")
1480                                .header("content-type", "application/grpc")
1481                                .body(empty_body())
1482                                .unwrap(),
1483                        )
1484                    })
1485                }
1486            }
1487        }
1488    }
1489    impl<T: RedisInstance> Clone for RedisInstanceServer<T> {
1490        fn clone(&self) -> Self {
1491            let inner = self.inner.clone();
1492            Self {
1493                inner,
1494                accept_compression_encodings: self.accept_compression_encodings,
1495                send_compression_encodings: self.send_compression_encodings,
1496                max_decoding_message_size: self.max_decoding_message_size,
1497                max_encoding_message_size: self.max_encoding_message_size,
1498            }
1499        }
1500    }
1501    impl<T: RedisInstance> Clone for _Inner<T> {
1502        fn clone(&self) -> Self {
1503            Self(Arc::clone(&self.0))
1504        }
1505    }
1506    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
1507        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1508            write!(f, "{:?}", self.0)
1509        }
1510    }
1511    impl<T: RedisInstance> tonic::server::NamedService for RedisInstanceServer<T> {
1512        const NAME: &'static str = "redis_instance.RedisInstance";
1513    }
1514}
volcengine_sdk_protobuf/protobuf/redis_instance.rs

volcengine_sdk_protobuf/protobuf/
redis_instance.rs
