xref: /aosp_15_r20/external/grpc-grpc/tools/run_tests/lb_interop_tests/gen_build_yaml.py (revision cc02d7e222339f7a4f6ba5f422e6413f4bd931f2) 
1#!/usr/bin/env python3
2# Copyright 2015 gRPC authors.
3#
4# Licensed under the Apache License, Version 2.0 (the "License");
5# you may not use this file except in compliance with the License.
6# You may obtain a copy of the License at
7#
8#     http://www.apache.org/licenses/LICENSE-2.0
9#
10# Unless required by applicable law or agreed to in writing, software
11# distributed under the License is distributed on an "AS IS" BASIS,
12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13# See the License for the specific language governing permissions and
14# limitations under the License.
15"""Generates the appropriate JSON data for LB interop test scenarios."""
16
17import json
18import os
19
20import yaml
21
22all_scenarios = []
23
24# TODO(https://github.com/grpc/grpc-go/issues/2347): enable
25# client_falls_back_because_no_backends_* scenarios for Java/Go.
26
27# TODO(https://github.com/grpc/grpc-java/issues/4887): enable
28# *short_stream* scenarios for Java.
29
30# TODO(https://github.com/grpc/grpc-java/issues/4912): enable
31# Java TLS tests involving TLS to the balancer.
32
33
34def server_sec(transport_sec):
35    if transport_sec == "google_default_credentials":
36        return "alts", "alts", "tls"
37    return transport_sec, transport_sec, transport_sec
38
39
40def generate_no_balancer_because_lb_a_record_returns_nx_domain():
41    all_configs = []
42    for transport_sec in [
43        "insecure",
44        "alts",
45        "tls",
46        "google_default_credentials",
47    ]:
48        balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
49        config = {
50            "name": "no_balancer_because_lb_a_record_returns_nx_domain_%s"
51            % transport_sec,
52            "skip_langs": [],
53            "transport_sec": transport_sec,
54            "balancer_configs": [],
55            "backend_configs": [],
56            "fallback_configs": [
57                {
58                    "transport_sec": fallback_sec,
59                }
60            ],
61            "cause_no_error_no_data_for_balancer_a_record": False,
62        }
63        all_configs.append(config)
64    return all_configs
65
66
67all_scenarios += generate_no_balancer_because_lb_a_record_returns_nx_domain()
68
69
70def generate_no_balancer_because_lb_a_record_returns_no_data():
71    all_configs = []
72    for transport_sec in [
73        "insecure",
74        "alts",
75        "tls",
76        "google_default_credentials",
77    ]:
78        balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
79        config = {
80            "name": "no_balancer_because_lb_a_record_returns_no_data_%s"
81            % transport_sec,
82            "skip_langs": [],
83            "transport_sec": transport_sec,
84            "balancer_configs": [],
85            "backend_configs": [],
86            "fallback_configs": [
87                {
88                    "transport_sec": fallback_sec,
89                }
90            ],
91            "cause_no_error_no_data_for_balancer_a_record": True,
92        }
93        all_configs.append(config)
94    return all_configs
95
96
97all_scenarios += generate_no_balancer_because_lb_a_record_returns_no_data()
98
99
100def generate_client_referred_to_backend():
101    all_configs = []
102    for balancer_short_stream in [True, False]:
103        for transport_sec in [
104            "insecure",
105            "alts",
106            "tls",
107            "google_default_credentials",
108        ]:
109            balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
110            skip_langs = []
111            if transport_sec == "tls":
112                skip_langs += ["java"]
113            if balancer_short_stream:
114                skip_langs += ["java"]
115            config = {
116                "name": "client_referred_to_backend_%s_short_stream_%s"
117                % (transport_sec, balancer_short_stream),
118                "skip_langs": skip_langs,
119                "transport_sec": transport_sec,
120                "balancer_configs": [
121                    {
122                        "transport_sec": balancer_sec,
123                        "short_stream": balancer_short_stream,
124                    }
125                ],
126                "backend_configs": [
127                    {
128                        "transport_sec": backend_sec,
129                    }
130                ],
131                "fallback_configs": [],
132                "cause_no_error_no_data_for_balancer_a_record": False,
133            }
134            all_configs.append(config)
135    return all_configs
136
137
138all_scenarios += generate_client_referred_to_backend()
139
140
141def generate_client_referred_to_backend_fallback_broken():
142    all_configs = []
143    for balancer_short_stream in [True, False]:
144        for transport_sec in ["alts", "tls", "google_default_credentials"]:
145            balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
146            skip_langs = []
147            if transport_sec == "tls":
148                skip_langs += ["java"]
149            if balancer_short_stream:
150                skip_langs += ["java"]
151            config = {
152                "name": "client_referred_to_backend_fallback_broken_%s_short_stream_%s"
153                % (transport_sec, balancer_short_stream),
154                "skip_langs": skip_langs,
155                "transport_sec": transport_sec,
156                "balancer_configs": [
157                    {
158                        "transport_sec": balancer_sec,
159                        "short_stream": balancer_short_stream,
160                    }
161                ],
162                "backend_configs": [
163                    {
164                        "transport_sec": backend_sec,
165                    }
166                ],
167                "fallback_configs": [
168                    {
169                        "transport_sec": "insecure",
170                    }
171                ],
172                "cause_no_error_no_data_for_balancer_a_record": False,
173            }
174            all_configs.append(config)
175    return all_configs
176
177
178all_scenarios += generate_client_referred_to_backend_fallback_broken()
179
180
181def generate_client_referred_to_backend_multiple_backends():
182    all_configs = []
183    for balancer_short_stream in [True, False]:
184        for transport_sec in [
185            "insecure",
186            "alts",
187            "tls",
188            "google_default_credentials",
189        ]:
190            balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
191            skip_langs = []
192            if transport_sec == "tls":
193                skip_langs += ["java"]
194            if balancer_short_stream:
195                skip_langs += ["java"]
196            config = {
197                "name": "client_referred_to_backend_multiple_backends_%s_short_stream_%s"
198                % (transport_sec, balancer_short_stream),
199                "skip_langs": skip_langs,
200                "transport_sec": transport_sec,
201                "balancer_configs": [
202                    {
203                        "transport_sec": balancer_sec,
204                        "short_stream": balancer_short_stream,
205                    }
206                ],
207                "backend_configs": [
208                    {
209                        "transport_sec": backend_sec,
210                    },
211                    {
212                        "transport_sec": backend_sec,
213                    },
214                    {
215                        "transport_sec": backend_sec,
216                    },
217                    {
218                        "transport_sec": backend_sec,
219                    },
220                    {
221                        "transport_sec": backend_sec,
222                    },
223                ],
224                "fallback_configs": [],
225                "cause_no_error_no_data_for_balancer_a_record": False,
226            }
227            all_configs.append(config)
228    return all_configs
229
230
231all_scenarios += generate_client_referred_to_backend_multiple_backends()
232
233
234def generate_client_falls_back_because_no_backends():
235    all_configs = []
236    for balancer_short_stream in [True, False]:
237        for transport_sec in [
238            "insecure",
239            "alts",
240            "tls",
241            "google_default_credentials",
242        ]:
243            balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
244            skip_langs = ["go", "java"]
245            if transport_sec == "tls":
246                skip_langs += ["java"]
247            if balancer_short_stream:
248                skip_langs += ["java"]
249            config = {
250                "name": (
251                    "client_falls_back_because_no_backends_%s_short_stream_%s"
252                )
253                % (transport_sec, balancer_short_stream),
254                "skip_langs": skip_langs,
255                "transport_sec": transport_sec,
256                "balancer_configs": [
257                    {
258                        "transport_sec": balancer_sec,
259                        "short_stream": balancer_short_stream,
260                    }
261                ],
262                "backend_configs": [],
263                "fallback_configs": [
264                    {
265                        "transport_sec": fallback_sec,
266                    }
267                ],
268                "cause_no_error_no_data_for_balancer_a_record": False,
269            }
270            all_configs.append(config)
271    return all_configs
272
273
274all_scenarios += generate_client_falls_back_because_no_backends()
275
276
277def generate_client_falls_back_because_balancer_connection_broken():
278    all_configs = []
279    for transport_sec in ["alts", "tls", "google_default_credentials"]:
280        balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
281        skip_langs = []
282        if transport_sec == "tls":
283            skip_langs = ["java"]
284        config = {
285            "name": "client_falls_back_because_balancer_connection_broken_%s"
286            % transport_sec,
287            "skip_langs": skip_langs,
288            "transport_sec": transport_sec,
289            "balancer_configs": [
290                {
291                    "transport_sec": "insecure",
292                    "short_stream": False,
293                }
294            ],
295            "backend_configs": [],
296            "fallback_configs": [
297                {
298                    "transport_sec": fallback_sec,
299                }
300            ],
301            "cause_no_error_no_data_for_balancer_a_record": False,
302        }
303        all_configs.append(config)
304    return all_configs
305
306
307all_scenarios += generate_client_falls_back_because_balancer_connection_broken()
308
309
310def generate_client_referred_to_backend_multiple_balancers():
311    all_configs = []
312    for balancer_short_stream in [True, False]:
313        for transport_sec in [
314            "insecure",
315            "alts",
316            "tls",
317            "google_default_credentials",
318        ]:
319            balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
320            skip_langs = []
321            if transport_sec == "tls":
322                skip_langs += ["java"]
323            if balancer_short_stream:
324                skip_langs += ["java"]
325            config = {
326                "name": "client_referred_to_backend_multiple_balancers_%s_short_stream_%s"
327                % (transport_sec, balancer_short_stream),
328                "skip_langs": skip_langs,
329                "transport_sec": transport_sec,
330                "balancer_configs": [
331                    {
332                        "transport_sec": balancer_sec,
333                        "short_stream": balancer_short_stream,
334                    },
335                    {
336                        "transport_sec": balancer_sec,
337                        "short_stream": balancer_short_stream,
338                    },
339                    {
340                        "transport_sec": balancer_sec,
341                        "short_stream": balancer_short_stream,
342                    },
343                    {
344                        "transport_sec": balancer_sec,
345                        "short_stream": balancer_short_stream,
346                    },
347                    {
348                        "transport_sec": balancer_sec,
349                        "short_stream": balancer_short_stream,
350                    },
351                ],
352                "backend_configs": [
353                    {
354                        "transport_sec": backend_sec,
355                    },
356                ],
357                "fallback_configs": [],
358                "cause_no_error_no_data_for_balancer_a_record": False,
359            }
360            all_configs.append(config)
361    return all_configs
362
363
364all_scenarios += generate_client_referred_to_backend_multiple_balancers()
365
366print(
367    (
368        yaml.dump(
369            {
370                "lb_interop_test_scenarios": all_scenarios,
371            }
372        )
373    )
374)
375