server_manual_cmd_log = [] if args.manual_run else None client_manual_cmd_log = [] if args.manual_run else None # Start interop servers. server_jobs = {} server_addresses = {} try: for s in servers: lang = str(s) spec = server_jobspec(_LANGUAGES[lang], docker_images.get(lang), args.insecure, manual_cmd_log=server_manual_cmd_log) if not args.manual_run: job = dockerjob.DockerJob(spec) server_jobs[lang] = job server_addresses[lang] = ('localhost', job.mapped_port(_DEFAULT_SERVER_PORT)) else: # don't run the server, set server port to a placeholder value server_addresses[lang] = ('localhost', '${SERVER_PORT}') http2_server_job = None if args.http2_server_interop: # launch a HTTP2 server emulator that creates edge cases lang = str(http2InteropServer) spec = server_jobspec(http2InteropServer, docker_images.get(lang), manual_cmd_log=server_manual_cmd_log) if not args.manual_run:
else: jobset.message('FAILED', 'Failed to build interop docker images.', do_newline=True) for image in docker_images.itervalues(): dockerjob.remove_image(image, skip_nonexistent=True) sys.exit(1) # Start interop servers. server_jobs = {} server_addresses = {} try: for s in servers: lang = str(s) spec = server_jobspec(_LANGUAGES[lang], docker_images.get(lang)) job = dockerjob.DockerJob(spec) server_jobs[lang] = job server_addresses[lang] = ('localhost', job.mapped_port(_DEFAULT_SERVER_PORT)) jobs = [] if args.cloud_to_prod: for server_host_name in args.prod_servers: for language in languages: for test_case in _TEST_CASES: if not test_case in language.unimplemented_test_cases(): if not test_case in _SKIP_ADVANCED + _SKIP_COMPRESSION: test_job = cloud_to_prod_jobspec( language, test_case, server_host_name,
def run_one_scenario(scenario_config): jobset.message('START', 'Run scenario: %s' % scenario_config['name']) server_jobs = {} server_addresses = {} suppress_server_logs = True try: backend_addrs = [] fallback_ips = [] grpclb_ips = [] shortname_prefix = scenario_config['name'] # Start backends for i in xrange(len(scenario_config['backend_configs'])): backend_config = scenario_config['backend_configs'][i] backend_shortname = shortname(shortname_prefix, 'backend_server', i) backend_spec = backend_server_jobspec( backend_config['transport_sec'], backend_shortname) backend_job = dockerjob.DockerJob(backend_spec) server_jobs[backend_shortname] = backend_job backend_addrs.append( '%s:%d' % (backend_job.ip_address(), _BACKEND_SERVER_PORT)) # Start fallbacks for i in xrange(len(scenario_config['fallback_configs'])): fallback_config = scenario_config['fallback_configs'][i] fallback_shortname = shortname(shortname_prefix, 'fallback_server', i) fallback_spec = fallback_server_jobspec( fallback_config['transport_sec'], fallback_shortname) fallback_job = dockerjob.DockerJob(fallback_spec) server_jobs[fallback_shortname] = fallback_job fallback_ips.append(fallback_job.ip_address()) # Start balancers for i in xrange(len(scenario_config['balancer_configs'])): balancer_config = scenario_config['balancer_configs'][i] grpclb_shortname = shortname(shortname_prefix, 'grpclb_server', i) grpclb_spec = grpclb_jobspec(balancer_config['transport_sec'], balancer_config['short_stream'], backend_addrs, grpclb_shortname) grpclb_job = dockerjob.DockerJob(grpclb_spec) server_jobs[grpclb_shortname] = grpclb_job grpclb_ips.append(grpclb_job.ip_address()) # Start DNS server dns_server_shortname = shortname(shortname_prefix, 'dns_server', 0) dns_server_spec = dns_server_in_docker_jobspec( grpclb_ips, fallback_ips, dns_server_shortname, scenario_config['cause_no_error_no_data_for_balancer_a_record']) dns_server_job = dockerjob.DockerJob(dns_server_spec) server_jobs[dns_server_shortname] = dns_server_job # Get the IP address of the docker container running the DNS server. # The DNS server is running on port 53 of that IP address. Note we will # point the DNS resolvers of grpc clients under test to our controlled # DNS server by effectively modifying the /etc/resolve.conf "nameserver" # lists of their docker containers. dns_server_ip = dns_server_job.ip_address() wait_until_dns_server_is_up(dns_server_ip) # Run clients jobs = [] for lang_name in languages: # Skip languages that are known to not currently # work for this test. if not args.no_skips and lang_name in scenario_config.get( 'skip_langs', []): jobset.message( 'IDLE', 'Skipping scenario: %s for language: %s\n' % (scenario_config['name'], lang_name)) continue lang = _LANGUAGES[lang_name] test_job = lb_client_interop_jobspec( lang, dns_server_ip, docker_image=docker_images.get(lang.safename), transport_security=scenario_config['transport_sec']) jobs.append(test_job) jobset.message( 'IDLE', 'Jobs to run: \n%s\n' % '\n'.join(str(job) for job in jobs)) num_failures, resultset = jobset.run(jobs, newline_on_success=True, maxjobs=args.jobs) report_utils.render_junit_xml_report(resultset, 'sponge_log.xml') if num_failures: suppress_server_logs = False jobset.message('FAILED', 'Scenario: %s. Some tests failed' % scenario_config['name'], do_newline=True) else: jobset.message('SUCCESS', 'Scenario: %s. All tests passed' % scenario_config['name'], do_newline=True) return num_failures finally: # Check if servers are still running. for server, job in server_jobs.items(): if not job.is_running(): print('Server "%s" has exited prematurely.' % server) suppress_failure = suppress_server_logs and not args.verbose dockerjob.finish_jobs([j for j in six.itervalues(server_jobs)], suppress_failure=suppress_failure)