camel-component-grpc 0.32.0

gRPC component for rust-camel (dynamic producer and consumer)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use camel_component_api::UriConfig;

#[allow(dead_code)]
#[derive(UriConfig)]
#[uri_scheme = "grpc"]
#[uri_config(
    skip_impl,
    descriptor,
    metadata(
        scheme = "grpc",
        description = "gRPC client/server",
        producer,
        consumer
    ),
    crate = "camel_component_api"
)]
pub(super) struct GrpcMetadataDescriptor {
    #[uri_param(name = "transport", required)]
    pub _transport: String,

    #[uri_param(name = "protoFile", required)]
    pub _proto_file: String,

    #[uri_param(name = "service")]
    pub _service: String,

    #[uri_param(name = "method")]
    pub _method: String,

    #[uri_param(name = "metadata")]
    pub _metadata: String,

    #[uri_param(name = "reflection", default = "false")]
    pub _reflection: bool,

    #[uri_param(name = "caCertPath")]
    pub _ca_cert_path: String,

    #[uri_param(name = "clientCertPath")]
    pub _client_cert_path: String,

    #[uri_param(name = "clientKeyPath")]
    pub _client_key_path: String,

    #[uri_param(name = "serverName")]
    pub _server_name: String,

    #[uri_param(name = "serverCertPath")]
    pub _server_cert_path: String,

    #[uri_param(name = "serverKeyPath")]
    pub _server_key_path: String,

    #[uri_param(name = "clientCaPath")]
    pub _client_ca_path: String,

    #[uri_param(name = "max_receive_message_length", default = "4194304")]
    pub _max_receive_message_length: u64,

    #[uri_param(name = "deadline_ms")]
    pub _deadline_ms: Option<u64>,

    #[uri_param(name = "connectTimeoutMs", default = "10000")]
    pub _connect_timeout_ms: u64,

    #[uri_param(name = "defaultDeadlineMs", default = "30000")]
    pub _default_deadline_ms: u64,

    #[uri_param(name = "bearerToken", secret)]
    pub _bearer_token: String,

    #[uri_param(name = "googleServiceAccount", secret)]
    pub _google_service_account: String,

    #[uri_param(name = "consumerStrategy")]
    pub _consumer_strategy: String,

    #[uri_param(name = "producerStrategy")]
    pub _producer_strategy: String,
}

#[cfg(test)]
mod tests {
    use super::*;
    use camel_component_api::ComponentMetadata;

    #[test]
    fn grpc_metadata_uri_options_parity() {
        let meta: ComponentMetadata = GrpcMetadataDescriptor::metadata();
        let mut names: Vec<&str> = meta.uri_options.iter().map(|o| o.name.as_str()).collect();
        names.sort();

        let mut expected = vec![
            "bearerToken",
            "caCertPath",
            "clientCaPath",
            "clientCertPath",
            "clientKeyPath",
            "connectTimeoutMs",
            "consumerStrategy",
            "deadline_ms",
            "defaultDeadlineMs",
            "googleServiceAccount",
            "max_receive_message_length",
            "metadata",
            "method",
            "producerStrategy",
            "protoFile",
            "reflection",
            "serverCertPath",
            "serverKeyPath",
            "serverName",
            "service",
            "transport",
        ];
        expected.sort();

        assert_eq!(
            names, expected,
            "metadata uri_options names must match parser keys"
        );

        // Verify required flags
        let transport = meta
            .uri_options
            .iter()
            .find(|o| o.name == "transport")
            .unwrap();
        assert!(transport.required, "transport must be required");

        let proto_file = meta
            .uri_options
            .iter()
            .find(|o| o.name == "protoFile")
            .unwrap();
        assert!(proto_file.required, "protoFile must be required");

        // Verify tls is absent (legacy param removed per ADR-0033)
        assert!(
            meta.uri_options.iter().all(|o| o.name != "tls"),
            "legacy 'tls' param must not appear in metadata"
        );

        // Verify secret flags
        let bearer_token = meta
            .uri_options
            .iter()
            .find(|o| o.name == "bearerToken")
            .unwrap();
        assert!(bearer_token.secret, "bearerToken must be secret");

        let google_service_account = meta
            .uri_options
            .iter()
            .find(|o| o.name == "googleServiceAccount")
            .unwrap();
        assert!(
            google_service_account.secret,
            "googleServiceAccount must be secret"
        );
    }
}