tools/run_tests/lb_interop_tests/gen_build_yaml.py

   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
  17 import json
  18 import os
  19 import yaml
  20
  21 all_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
  33 def 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
  39 def 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
  64 all_scenarios += generate_no_balancer_because_lb_a_record_returns_nx_domain()
  65
  66
  67 def 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
  92 all_scenarios += generate_no_balancer_because_lb_a_record_returns_no_data()
  93
  94
  95 def 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
 130 all_scenarios += generate_client_referred_to_backend()
 131
 132
 133 def 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
 168 all_scenarios += generate_client_referred_to_backend_fallback_broken()
 169
 170
 171 def 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
 214 all_scenarios += generate_client_referred_to_backend_multiple_backends()
 215
 216
 217 def 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
 252 all_scenarios += generate_client_falls_back_because_no_backends()
 253
 254
 255 def 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
 285 all_scenarios += generate_client_falls_back_because_balancer_connection_broken()
 286
 287
 288 def 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
 341 all_scenarios += generate_client_referred_to_backend_multiple_balancers()
 342
 343 print(yaml.dump({
 344     'lb_interop_test_scenarios': all_scenarios,
 345 }))