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', 'alts', 'tls', 'google_default_credentials'
44    ]:
45        balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
46        config = {
47            'name':
48                'no_balancer_because_lb_a_record_returns_nx_domain_%s' %
49                transport_sec,
50            'skip_langs': [],
51            'transport_sec':
52                transport_sec,
53            'balancer_configs': [],
54            'backend_configs': [],
55            'fallback_configs': [{
56                'transport_sec': fallback_sec,
57            }],
58            'cause_no_error_no_data_for_balancer_a_record':
59                False,
60        }
61        all_configs.append(config)
62    return all_configs
63
64
65all_scenarios += generate_no_balancer_because_lb_a_record_returns_nx_domain()
66
67
68def generate_no_balancer_because_lb_a_record_returns_no_data():
69    all_configs = []
70    for transport_sec in [
71            'insecure', 'alts', 'tls', 'google_default_credentials'
72    ]:
73        balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
74        config = {
75            'name':
76                'no_balancer_because_lb_a_record_returns_no_data_%s' %
77                transport_sec,
78            'skip_langs': [],
79            'transport_sec':
80                transport_sec,
81            'balancer_configs': [],
82            'backend_configs': [],
83            'fallback_configs': [{
84                'transport_sec': fallback_sec,
85            }],
86            'cause_no_error_no_data_for_balancer_a_record':
87                True,
88        }
89        all_configs.append(config)
90    return all_configs
91
92
93all_scenarios += generate_no_balancer_because_lb_a_record_returns_no_data()
94
95
96def generate_client_referred_to_backend():
97    all_configs = []
98    for balancer_short_stream in [True, False]:
99        for transport_sec in [
100                'insecure', 'alts', 'tls', 'google_default_credentials'
101        ]:
102            balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
103            skip_langs = []
104            if transport_sec == 'tls':
105                skip_langs += ['java']
106            if balancer_short_stream:
107                skip_langs += ['java']
108            config = {
109                'name':
110                    'client_referred_to_backend_%s_short_stream_%s' %
111                    (transport_sec, balancer_short_stream),
112                'skip_langs':
113                    skip_langs,
114                'transport_sec':
115                    transport_sec,
116                'balancer_configs': [{
117                    'transport_sec': balancer_sec,
118                    'short_stream': balancer_short_stream,
119                }],
120                'backend_configs': [{
121                    'transport_sec': backend_sec,
122                }],
123                'fallback_configs': [],
124                'cause_no_error_no_data_for_balancer_a_record':
125                    False,
126            }
127            all_configs.append(config)
128    return all_configs
129
130
131all_scenarios += generate_client_referred_to_backend()
132
133
134def generate_client_referred_to_backend_fallback_broken():
135    all_configs = []
136    for balancer_short_stream in [True, False]:
137        for transport_sec in ['alts', 'tls', 'google_default_credentials']:
138            balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
139            skip_langs = []
140            if transport_sec == 'tls':
141                skip_langs += ['java']
142            if balancer_short_stream:
143                skip_langs += ['java']
144            config = {
145                'name':
146                    'client_referred_to_backend_fallback_broken_%s_short_stream_%s'
147                    % (transport_sec, balancer_short_stream),
148                'skip_langs':
149                    skip_langs,
150                'transport_sec':
151                    transport_sec,
152                'balancer_configs': [{
153                    'transport_sec': balancer_sec,
154                    'short_stream': balancer_short_stream,
155                }],
156                'backend_configs': [{
157                    'transport_sec': backend_sec,
158                }],
159                'fallback_configs': [{
160                    'transport_sec': 'insecure',
161                }],
162                'cause_no_error_no_data_for_balancer_a_record':
163                    False,
164            }
165            all_configs.append(config)
166    return all_configs
167
168
169all_scenarios += generate_client_referred_to_backend_fallback_broken()
170
171
172def generate_client_referred_to_backend_multiple_backends():
173    all_configs = []
174    for balancer_short_stream in [True, False]:
175        for transport_sec in [
176                'insecure', 'alts', 'tls', 'google_default_credentials'
177        ]:
178            balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
179            skip_langs = []
180            if transport_sec == 'tls':
181                skip_langs += ['java']
182            if balancer_short_stream:
183                skip_langs += ['java']
184            config = {
185                'name':
186                    'client_referred_to_backend_multiple_backends_%s_short_stream_%s'
187                    % (transport_sec, balancer_short_stream),
188                'skip_langs':
189                    skip_langs,
190                'transport_sec':
191                    transport_sec,
192                'balancer_configs': [{
193                    'transport_sec': balancer_sec,
194                    'short_stream': balancer_short_stream,
195                }],
196                'backend_configs': [{
197                    'transport_sec': backend_sec,
198                }, {
199                    'transport_sec': backend_sec,
200                }, {
201                    'transport_sec': backend_sec,
202                }, {
203                    'transport_sec': backend_sec,
204                }, {
205                    'transport_sec': backend_sec,
206                }],
207                'fallback_configs': [],
208                'cause_no_error_no_data_for_balancer_a_record':
209                    False,
210            }
211            all_configs.append(config)
212    return all_configs
213
214
215all_scenarios += generate_client_referred_to_backend_multiple_backends()
216
217
218def generate_client_falls_back_because_no_backends():
219    all_configs = []
220    for balancer_short_stream in [True, False]:
221        for transport_sec in [
222                'insecure', 'alts', 'tls', 'google_default_credentials'
223        ]:
224            balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
225            skip_langs = ['go', 'java']
226            if transport_sec == 'tls':
227                skip_langs += ['java']
228            if balancer_short_stream:
229                skip_langs += ['java']
230            config = {
231                'name':
232                    'client_falls_back_because_no_backends_%s_short_stream_%s' %
233                    (transport_sec, balancer_short_stream),
234                'skip_langs':
235                    skip_langs,
236                'transport_sec':
237                    transport_sec,
238                'balancer_configs': [{
239                    'transport_sec': balancer_sec,
240                    'short_stream': balancer_short_stream,
241                }],
242                'backend_configs': [],
243                'fallback_configs': [{
244                    'transport_sec': fallback_sec,
245                }],
246                'cause_no_error_no_data_for_balancer_a_record':
247                    False,
248            }
249            all_configs.append(config)
250    return all_configs
251
252
253all_scenarios += generate_client_falls_back_because_no_backends()
254
255
256def generate_client_falls_back_because_balancer_connection_broken():
257    all_configs = []
258    for transport_sec in ['alts', 'tls', 'google_default_credentials']:
259        balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
260        skip_langs = []
261        if transport_sec == 'tls':
262            skip_langs = ['java']
263        config = {
264            'name':
265                'client_falls_back_because_balancer_connection_broken_%s' %
266                transport_sec,
267            'skip_langs':
268                skip_langs,
269            'transport_sec':
270                transport_sec,
271            'balancer_configs': [{
272                'transport_sec': 'insecure',
273                'short_stream': False,
274            }],
275            'backend_configs': [],
276            'fallback_configs': [{
277                'transport_sec': fallback_sec,
278            }],
279            'cause_no_error_no_data_for_balancer_a_record':
280                False,
281        }
282        all_configs.append(config)
283    return all_configs
284
285
286all_scenarios += generate_client_falls_back_because_balancer_connection_broken()
287
288
289def generate_client_referred_to_backend_multiple_balancers():
290    all_configs = []
291    for balancer_short_stream in [True, False]:
292        for transport_sec in [
293                'insecure', 'alts', 'tls', 'google_default_credentials'
294        ]:
295            balancer_sec, backend_sec, fallback_sec = server_sec(transport_sec)
296            skip_langs = []
297            if transport_sec == 'tls':
298                skip_langs += ['java']
299            if balancer_short_stream:
300                skip_langs += ['java']
301            config = {
302                'name':
303                    'client_referred_to_backend_multiple_balancers_%s_short_stream_%s'
304                    % (transport_sec, balancer_short_stream),
305                'skip_langs':
306                    skip_langs,
307                'transport_sec':
308                    transport_sec,
309                'balancer_configs': [
310                    {
311                        'transport_sec': balancer_sec,
312                        'short_stream': balancer_short_stream,
313                    },
314                    {
315                        'transport_sec': balancer_sec,
316                        'short_stream': balancer_short_stream,
317                    },
318                    {
319                        'transport_sec': balancer_sec,
320                        'short_stream': balancer_short_stream,
321                    },
322                    {
323                        'transport_sec': balancer_sec,
324                        'short_stream': balancer_short_stream,
325                    },
326                    {
327                        'transport_sec': balancer_sec,
328                        'short_stream': balancer_short_stream,
329                    },
330                ],
331                'backend_configs': [{
332                    'transport_sec': backend_sec,
333                },],
334                'fallback_configs': [],
335                'cause_no_error_no_data_for_balancer_a_record':
336                    False,
337            }
338            all_configs.append(config)
339    return all_configs
340
341
342all_scenarios += generate_client_referred_to_backend_multiple_balancers()
343
344print((yaml.dump({
345    'lb_interop_test_scenarios': all_scenarios,
346})))
347