risingwave_pb/
secret.serde.rs

1use crate::secret::*;
2impl serde::Serialize for Secret {
3    #[allow(deprecated)]
4    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5    where
6        S: serde::Serializer,
7    {
8        use serde::ser::SerializeStruct;
9        let mut len = 0;
10        if self.secret_backend.is_some() {
11            len += 1;
12        }
13        let mut struct_ser = serializer.serialize_struct("secret.Secret", len)?;
14        if let Some(v) = self.secret_backend.as_ref() {
15            match v {
16                secret::SecretBackend::Meta(v) => {
17                    struct_ser.serialize_field("meta", v)?;
18                }
19                secret::SecretBackend::HashicorpVault(v) => {
20                    struct_ser.serialize_field("hashicorpVault", v)?;
21                }
22            }
23        }
24        struct_ser.end()
25    }
26}
27impl<'de> serde::Deserialize<'de> for Secret {
28    #[allow(deprecated)]
29    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
30    where
31        D: serde::Deserializer<'de>,
32    {
33        const FIELDS: &[&str] = &[
34            "meta",
35            "hashicorp_vault",
36            "hashicorpVault",
37        ];
38
39        #[allow(clippy::enum_variant_names)]
40        enum GeneratedField {
41            Meta,
42            HashicorpVault,
43        }
44        impl<'de> serde::Deserialize<'de> for GeneratedField {
45            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
46            where
47                D: serde::Deserializer<'de>,
48            {
49                struct GeneratedVisitor;
50
51                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
52                    type Value = GeneratedField;
53
54                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
55                        write!(formatter, "expected one of: {:?}", &FIELDS)
56                    }
57
58                    #[allow(unused_variables)]
59                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
60                    where
61                        E: serde::de::Error,
62                    {
63                        match value {
64                            "meta" => Ok(GeneratedField::Meta),
65                            "hashicorpVault" | "hashicorp_vault" => Ok(GeneratedField::HashicorpVault),
66                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
67                        }
68                    }
69                }
70                deserializer.deserialize_identifier(GeneratedVisitor)
71            }
72        }
73        struct GeneratedVisitor;
74        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
75            type Value = Secret;
76
77            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
78                formatter.write_str("struct secret.Secret")
79            }
80
81            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Secret, V::Error>
82                where
83                    V: serde::de::MapAccess<'de>,
84            {
85                let mut secret_backend__ = None;
86                while let Some(k) = map_.next_key()? {
87                    match k {
88                        GeneratedField::Meta => {
89                            if secret_backend__.is_some() {
90                                return Err(serde::de::Error::duplicate_field("meta"));
91                            }
92                            secret_backend__ = map_.next_value::<::std::option::Option<_>>()?.map(secret::SecretBackend::Meta)
93;
94                        }
95                        GeneratedField::HashicorpVault => {
96                            if secret_backend__.is_some() {
97                                return Err(serde::de::Error::duplicate_field("hashicorpVault"));
98                            }
99                            secret_backend__ = map_.next_value::<::std::option::Option<_>>()?.map(secret::SecretBackend::HashicorpVault)
100;
101                        }
102                    }
103                }
104                Ok(Secret {
105                    secret_backend: secret_backend__,
106                })
107            }
108        }
109        deserializer.deserialize_struct("secret.Secret", FIELDS, GeneratedVisitor)
110    }
111}
112impl serde::Serialize for SecretHashicorpVaultBackend {
113    #[allow(deprecated)]
114    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
115    where
116        S: serde::Serializer,
117    {
118        use serde::ser::SerializeStruct;
119        let mut len = 0;
120        if !self.addr.is_empty() {
121            len += 1;
122        }
123        if !self.path.is_empty() {
124            len += 1;
125        }
126        if !self.field.is_empty() {
127            len += 1;
128        }
129        if self.tls_skip_verify {
130            len += 1;
131        }
132        if self.auth.is_some() {
133            len += 1;
134        }
135        let mut struct_ser = serializer.serialize_struct("secret.SecretHashicorpVaultBackend", len)?;
136        if !self.addr.is_empty() {
137            struct_ser.serialize_field("addr", &self.addr)?;
138        }
139        if !self.path.is_empty() {
140            struct_ser.serialize_field("path", &self.path)?;
141        }
142        if !self.field.is_empty() {
143            struct_ser.serialize_field("field", &self.field)?;
144        }
145        if self.tls_skip_verify {
146            struct_ser.serialize_field("tlsSkipVerify", &self.tls_skip_verify)?;
147        }
148        if let Some(v) = self.auth.as_ref() {
149            match v {
150                secret_hashicorp_vault_backend::Auth::TokenAuth(v) => {
151                    struct_ser.serialize_field("tokenAuth", v)?;
152                }
153                secret_hashicorp_vault_backend::Auth::ApproleAuth(v) => {
154                    struct_ser.serialize_field("approleAuth", v)?;
155                }
156            }
157        }
158        struct_ser.end()
159    }
160}
161impl<'de> serde::Deserialize<'de> for SecretHashicorpVaultBackend {
162    #[allow(deprecated)]
163    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
164    where
165        D: serde::Deserializer<'de>,
166    {
167        const FIELDS: &[&str] = &[
168            "addr",
169            "path",
170            "field",
171            "tls_skip_verify",
172            "tlsSkipVerify",
173            "token_auth",
174            "tokenAuth",
175            "approle_auth",
176            "approleAuth",
177        ];
178
179        #[allow(clippy::enum_variant_names)]
180        enum GeneratedField {
181            Addr,
182            Path,
183            Field,
184            TlsSkipVerify,
185            TokenAuth,
186            ApproleAuth,
187        }
188        impl<'de> serde::Deserialize<'de> for GeneratedField {
189            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
190            where
191                D: serde::Deserializer<'de>,
192            {
193                struct GeneratedVisitor;
194
195                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
196                    type Value = GeneratedField;
197
198                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
199                        write!(formatter, "expected one of: {:?}", &FIELDS)
200                    }
201
202                    #[allow(unused_variables)]
203                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
204                    where
205                        E: serde::de::Error,
206                    {
207                        match value {
208                            "addr" => Ok(GeneratedField::Addr),
209                            "path" => Ok(GeneratedField::Path),
210                            "field" => Ok(GeneratedField::Field),
211                            "tlsSkipVerify" | "tls_skip_verify" => Ok(GeneratedField::TlsSkipVerify),
212                            "tokenAuth" | "token_auth" => Ok(GeneratedField::TokenAuth),
213                            "approleAuth" | "approle_auth" => Ok(GeneratedField::ApproleAuth),
214                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
215                        }
216                    }
217                }
218                deserializer.deserialize_identifier(GeneratedVisitor)
219            }
220        }
221        struct GeneratedVisitor;
222        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
223            type Value = SecretHashicorpVaultBackend;
224
225            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
226                formatter.write_str("struct secret.SecretHashicorpVaultBackend")
227            }
228
229            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SecretHashicorpVaultBackend, V::Error>
230                where
231                    V: serde::de::MapAccess<'de>,
232            {
233                let mut addr__ = None;
234                let mut path__ = None;
235                let mut field__ = None;
236                let mut tls_skip_verify__ = None;
237                let mut auth__ = None;
238                while let Some(k) = map_.next_key()? {
239                    match k {
240                        GeneratedField::Addr => {
241                            if addr__.is_some() {
242                                return Err(serde::de::Error::duplicate_field("addr"));
243                            }
244                            addr__ = Some(map_.next_value()?);
245                        }
246                        GeneratedField::Path => {
247                            if path__.is_some() {
248                                return Err(serde::de::Error::duplicate_field("path"));
249                            }
250                            path__ = Some(map_.next_value()?);
251                        }
252                        GeneratedField::Field => {
253                            if field__.is_some() {
254                                return Err(serde::de::Error::duplicate_field("field"));
255                            }
256                            field__ = Some(map_.next_value()?);
257                        }
258                        GeneratedField::TlsSkipVerify => {
259                            if tls_skip_verify__.is_some() {
260                                return Err(serde::de::Error::duplicate_field("tlsSkipVerify"));
261                            }
262                            tls_skip_verify__ = Some(map_.next_value()?);
263                        }
264                        GeneratedField::TokenAuth => {
265                            if auth__.is_some() {
266                                return Err(serde::de::Error::duplicate_field("tokenAuth"));
267                            }
268                            auth__ = map_.next_value::<::std::option::Option<_>>()?.map(secret_hashicorp_vault_backend::Auth::TokenAuth)
269;
270                        }
271                        GeneratedField::ApproleAuth => {
272                            if auth__.is_some() {
273                                return Err(serde::de::Error::duplicate_field("approleAuth"));
274                            }
275                            auth__ = map_.next_value::<::std::option::Option<_>>()?.map(secret_hashicorp_vault_backend::Auth::ApproleAuth)
276;
277                        }
278                    }
279                }
280                Ok(SecretHashicorpVaultBackend {
281                    addr: addr__.unwrap_or_default(),
282                    path: path__.unwrap_or_default(),
283                    field: field__.unwrap_or_default(),
284                    tls_skip_verify: tls_skip_verify__.unwrap_or_default(),
285                    auth: auth__,
286                })
287            }
288        }
289        deserializer.deserialize_struct("secret.SecretHashicorpVaultBackend", FIELDS, GeneratedVisitor)
290    }
291}
292impl serde::Serialize for SecretMetaBackend {
293    #[allow(deprecated)]
294    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
295    where
296        S: serde::Serializer,
297    {
298        use serde::ser::SerializeStruct;
299        let mut len = 0;
300        if !self.value.is_empty() {
301            len += 1;
302        }
303        let mut struct_ser = serializer.serialize_struct("secret.SecretMetaBackend", len)?;
304        if !self.value.is_empty() {
305            #[allow(clippy::needless_borrow)]
306            #[allow(clippy::needless_borrows_for_generic_args)]
307            struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
308        }
309        struct_ser.end()
310    }
311}
312impl<'de> serde::Deserialize<'de> for SecretMetaBackend {
313    #[allow(deprecated)]
314    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
315    where
316        D: serde::Deserializer<'de>,
317    {
318        const FIELDS: &[&str] = &[
319            "value",
320        ];
321
322        #[allow(clippy::enum_variant_names)]
323        enum GeneratedField {
324            Value,
325        }
326        impl<'de> serde::Deserialize<'de> for GeneratedField {
327            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
328            where
329                D: serde::Deserializer<'de>,
330            {
331                struct GeneratedVisitor;
332
333                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
334                    type Value = GeneratedField;
335
336                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
337                        write!(formatter, "expected one of: {:?}", &FIELDS)
338                    }
339
340                    #[allow(unused_variables)]
341                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
342                    where
343                        E: serde::de::Error,
344                    {
345                        match value {
346                            "value" => Ok(GeneratedField::Value),
347                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
348                        }
349                    }
350                }
351                deserializer.deserialize_identifier(GeneratedVisitor)
352            }
353        }
354        struct GeneratedVisitor;
355        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
356            type Value = SecretMetaBackend;
357
358            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
359                formatter.write_str("struct secret.SecretMetaBackend")
360            }
361
362            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SecretMetaBackend, V::Error>
363                where
364                    V: serde::de::MapAccess<'de>,
365            {
366                let mut value__ = None;
367                while let Some(k) = map_.next_key()? {
368                    match k {
369                        GeneratedField::Value => {
370                            if value__.is_some() {
371                                return Err(serde::de::Error::duplicate_field("value"));
372                            }
373                            value__ = 
374                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
375                            ;
376                        }
377                    }
378                }
379                Ok(SecretMetaBackend {
380                    value: value__.unwrap_or_default(),
381                })
382            }
383        }
384        deserializer.deserialize_struct("secret.SecretMetaBackend", FIELDS, GeneratedVisitor)
385    }
386}
387impl serde::Serialize for SecretRef {
388    #[allow(deprecated)]
389    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
390    where
391        S: serde::Serializer,
392    {
393        use serde::ser::SerializeStruct;
394        let mut len = 0;
395        if self.secret_id != 0 {
396            len += 1;
397        }
398        if self.ref_as != 0 {
399            len += 1;
400        }
401        let mut struct_ser = serializer.serialize_struct("secret.SecretRef", len)?;
402        if self.secret_id != 0 {
403            struct_ser.serialize_field("secretId", &self.secret_id)?;
404        }
405        if self.ref_as != 0 {
406            let v = secret_ref::RefAsType::try_from(self.ref_as)
407                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.ref_as)))?;
408            struct_ser.serialize_field("refAs", &v)?;
409        }
410        struct_ser.end()
411    }
412}
413impl<'de> serde::Deserialize<'de> for SecretRef {
414    #[allow(deprecated)]
415    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
416    where
417        D: serde::Deserializer<'de>,
418    {
419        const FIELDS: &[&str] = &[
420            "secret_id",
421            "secretId",
422            "ref_as",
423            "refAs",
424        ];
425
426        #[allow(clippy::enum_variant_names)]
427        enum GeneratedField {
428            SecretId,
429            RefAs,
430        }
431        impl<'de> serde::Deserialize<'de> for GeneratedField {
432            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
433            where
434                D: serde::Deserializer<'de>,
435            {
436                struct GeneratedVisitor;
437
438                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
439                    type Value = GeneratedField;
440
441                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
442                        write!(formatter, "expected one of: {:?}", &FIELDS)
443                    }
444
445                    #[allow(unused_variables)]
446                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
447                    where
448                        E: serde::de::Error,
449                    {
450                        match value {
451                            "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
452                            "refAs" | "ref_as" => Ok(GeneratedField::RefAs),
453                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
454                        }
455                    }
456                }
457                deserializer.deserialize_identifier(GeneratedVisitor)
458            }
459        }
460        struct GeneratedVisitor;
461        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
462            type Value = SecretRef;
463
464            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
465                formatter.write_str("struct secret.SecretRef")
466            }
467
468            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SecretRef, V::Error>
469                where
470                    V: serde::de::MapAccess<'de>,
471            {
472                let mut secret_id__ = None;
473                let mut ref_as__ = None;
474                while let Some(k) = map_.next_key()? {
475                    match k {
476                        GeneratedField::SecretId => {
477                            if secret_id__.is_some() {
478                                return Err(serde::de::Error::duplicate_field("secretId"));
479                            }
480                            secret_id__ = 
481                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
482                            ;
483                        }
484                        GeneratedField::RefAs => {
485                            if ref_as__.is_some() {
486                                return Err(serde::de::Error::duplicate_field("refAs"));
487                            }
488                            ref_as__ = Some(map_.next_value::<secret_ref::RefAsType>()? as i32);
489                        }
490                    }
491                }
492                Ok(SecretRef {
493                    secret_id: secret_id__.unwrap_or_default(),
494                    ref_as: ref_as__.unwrap_or_default(),
495                })
496            }
497        }
498        deserializer.deserialize_struct("secret.SecretRef", FIELDS, GeneratedVisitor)
499    }
500}
501impl serde::Serialize for secret_ref::RefAsType {
502    #[allow(deprecated)]
503    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
504    where
505        S: serde::Serializer,
506    {
507        let variant = match self {
508            Self::Unspecified => "UNSPECIFIED",
509            Self::Text => "TEXT",
510            Self::File => "FILE",
511        };
512        serializer.serialize_str(variant)
513    }
514}
515impl<'de> serde::Deserialize<'de> for secret_ref::RefAsType {
516    #[allow(deprecated)]
517    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
518    where
519        D: serde::Deserializer<'de>,
520    {
521        const FIELDS: &[&str] = &[
522            "UNSPECIFIED",
523            "TEXT",
524            "FILE",
525        ];
526
527        struct GeneratedVisitor;
528
529        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
530            type Value = secret_ref::RefAsType;
531
532            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
533                write!(formatter, "expected one of: {:?}", &FIELDS)
534            }
535
536            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
537            where
538                E: serde::de::Error,
539            {
540                i32::try_from(v)
541                    .ok()
542                    .and_then(|x| x.try_into().ok())
543                    .ok_or_else(|| {
544                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
545                    })
546            }
547
548            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
549            where
550                E: serde::de::Error,
551            {
552                i32::try_from(v)
553                    .ok()
554                    .and_then(|x| x.try_into().ok())
555                    .ok_or_else(|| {
556                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
557                    })
558            }
559
560            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
561            where
562                E: serde::de::Error,
563            {
564                match value {
565                    "UNSPECIFIED" => Ok(secret_ref::RefAsType::Unspecified),
566                    "TEXT" => Ok(secret_ref::RefAsType::Text),
567                    "FILE" => Ok(secret_ref::RefAsType::File),
568                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
569                }
570            }
571        }
572        deserializer.deserialize_any(GeneratedVisitor)
573    }
574}
575impl serde::Serialize for VaultAppRoleAuth {
576    #[allow(deprecated)]
577    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
578    where
579        S: serde::Serializer,
580    {
581        use serde::ser::SerializeStruct;
582        let mut len = 0;
583        if !self.role_id.is_empty() {
584            len += 1;
585        }
586        if !self.secret_id.is_empty() {
587            len += 1;
588        }
589        let mut struct_ser = serializer.serialize_struct("secret.VaultAppRoleAuth", len)?;
590        if !self.role_id.is_empty() {
591            struct_ser.serialize_field("roleId", &self.role_id)?;
592        }
593        if !self.secret_id.is_empty() {
594            struct_ser.serialize_field("secretId", &self.secret_id)?;
595        }
596        struct_ser.end()
597    }
598}
599impl<'de> serde::Deserialize<'de> for VaultAppRoleAuth {
600    #[allow(deprecated)]
601    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
602    where
603        D: serde::Deserializer<'de>,
604    {
605        const FIELDS: &[&str] = &[
606            "role_id",
607            "roleId",
608            "secret_id",
609            "secretId",
610        ];
611
612        #[allow(clippy::enum_variant_names)]
613        enum GeneratedField {
614            RoleId,
615            SecretId,
616        }
617        impl<'de> serde::Deserialize<'de> for GeneratedField {
618            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
619            where
620                D: serde::Deserializer<'de>,
621            {
622                struct GeneratedVisitor;
623
624                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
625                    type Value = GeneratedField;
626
627                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
628                        write!(formatter, "expected one of: {:?}", &FIELDS)
629                    }
630
631                    #[allow(unused_variables)]
632                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
633                    where
634                        E: serde::de::Error,
635                    {
636                        match value {
637                            "roleId" | "role_id" => Ok(GeneratedField::RoleId),
638                            "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
639                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
640                        }
641                    }
642                }
643                deserializer.deserialize_identifier(GeneratedVisitor)
644            }
645        }
646        struct GeneratedVisitor;
647        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
648            type Value = VaultAppRoleAuth;
649
650            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
651                formatter.write_str("struct secret.VaultAppRoleAuth")
652            }
653
654            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VaultAppRoleAuth, V::Error>
655                where
656                    V: serde::de::MapAccess<'de>,
657            {
658                let mut role_id__ = None;
659                let mut secret_id__ = None;
660                while let Some(k) = map_.next_key()? {
661                    match k {
662                        GeneratedField::RoleId => {
663                            if role_id__.is_some() {
664                                return Err(serde::de::Error::duplicate_field("roleId"));
665                            }
666                            role_id__ = Some(map_.next_value()?);
667                        }
668                        GeneratedField::SecretId => {
669                            if secret_id__.is_some() {
670                                return Err(serde::de::Error::duplicate_field("secretId"));
671                            }
672                            secret_id__ = Some(map_.next_value()?);
673                        }
674                    }
675                }
676                Ok(VaultAppRoleAuth {
677                    role_id: role_id__.unwrap_or_default(),
678                    secret_id: secret_id__.unwrap_or_default(),
679                })
680            }
681        }
682        deserializer.deserialize_struct("secret.VaultAppRoleAuth", FIELDS, GeneratedVisitor)
683    }
684}
685impl serde::Serialize for VaultTokenAuth {
686    #[allow(deprecated)]
687    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
688    where
689        S: serde::Serializer,
690    {
691        use serde::ser::SerializeStruct;
692        let mut len = 0;
693        if !self.token.is_empty() {
694            len += 1;
695        }
696        let mut struct_ser = serializer.serialize_struct("secret.VaultTokenAuth", len)?;
697        if !self.token.is_empty() {
698            struct_ser.serialize_field("token", &self.token)?;
699        }
700        struct_ser.end()
701    }
702}
703impl<'de> serde::Deserialize<'de> for VaultTokenAuth {
704    #[allow(deprecated)]
705    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
706    where
707        D: serde::Deserializer<'de>,
708    {
709        const FIELDS: &[&str] = &[
710            "token",
711        ];
712
713        #[allow(clippy::enum_variant_names)]
714        enum GeneratedField {
715            Token,
716        }
717        impl<'de> serde::Deserialize<'de> for GeneratedField {
718            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
719            where
720                D: serde::Deserializer<'de>,
721            {
722                struct GeneratedVisitor;
723
724                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
725                    type Value = GeneratedField;
726
727                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
728                        write!(formatter, "expected one of: {:?}", &FIELDS)
729                    }
730
731                    #[allow(unused_variables)]
732                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
733                    where
734                        E: serde::de::Error,
735                    {
736                        match value {
737                            "token" => Ok(GeneratedField::Token),
738                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
739                        }
740                    }
741                }
742                deserializer.deserialize_identifier(GeneratedVisitor)
743            }
744        }
745        struct GeneratedVisitor;
746        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
747            type Value = VaultTokenAuth;
748
749            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
750                formatter.write_str("struct secret.VaultTokenAuth")
751            }
752
753            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VaultTokenAuth, V::Error>
754                where
755                    V: serde::de::MapAccess<'de>,
756            {
757                let mut token__ = None;
758                while let Some(k) = map_.next_key()? {
759                    match k {
760                        GeneratedField::Token => {
761                            if token__.is_some() {
762                                return Err(serde::de::Error::duplicate_field("token"));
763                            }
764                            token__ = Some(map_.next_value()?);
765                        }
766                    }
767                }
768                Ok(VaultTokenAuth {
769                    token: token__.unwrap_or_default(),
770                })
771            }
772        }
773        deserializer.deserialize_struct("secret.VaultTokenAuth", FIELDS, GeneratedVisitor)
774    }
775}
risingwave_pb/secret.serde.rs

risingwave_pb/
secret.serde.rs
