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