Remove check for whether channel is secure/insecure. Always prefer 'https_proxy' and fallback on 'http_proxy'

pull/15698/head
Yash Tibrewal 7 years ago
parent 84328e733d
commit 2bf8ef24a1
  1. 4
      BUILD
  2. 30
      CMakeLists.txt
  3. 34
      Makefile
  4. 32
      src/core/ext/filters/client_channel/http_proxy.cc
  5. 5
      test/core/end2end/BUILD
  6. 64
      test/core/end2end/fixtures/h2_http_proxy.cc
  7. 129
      test/core/end2end/fixtures/h2_https_proxy.cc
  8. 49
      test/core/end2end/fixtures/http_proxy_fixture.cc
  9. 19
      test/core/end2end/fixtures/http_proxy_fixture.h
  10. 2
      test/core/end2end/gen_build_yaml.py
  11. 1
      test/core/end2end/generate_tests.bzl
  12. 18
      tools/run_tests/generated/sources_and_headers.json
  13. 1872
      tools/run_tests/generated/tests.json

@ -1068,10 +1068,6 @@ grpc_cc_library(
"src/core/ext/filters/client_channel/subchannel.h",
"src/core/ext/filters/client_channel/subchannel_index.h",
"src/core/ext/filters/client_channel/uri_parser.h",
"src/core/lib/security/credentials/credentials.h",
"src/core/lib/security/security_connector/security_connector.h",
"src/core/tsi/ssl_transport_security.h",
"src/core/tsi/transport_security_interface.h",
],
language = "c++",
deps = [

@ -425,7 +425,6 @@ endif()
add_dependencies(buildtests_c h2_full+trace_test)
add_dependencies(buildtests_c h2_full+workarounds_test)
add_dependencies(buildtests_c h2_http_proxy_test)
add_dependencies(buildtests_c h2_https_proxy_test)
add_dependencies(buildtests_c h2_load_reporting_test)
add_dependencies(buildtests_c h2_oauth2_test)
add_dependencies(buildtests_c h2_proxy_test)
@ -14865,35 +14864,6 @@ target_link_libraries(h2_http_proxy_test
endif (gRPC_BUILD_TESTS)
if (gRPC_BUILD_TESTS)
add_executable(h2_https_proxy_test
test/core/end2end/fixtures/h2_https_proxy.cc
)
target_include_directories(h2_https_proxy_test
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include
PRIVATE ${_gRPC_SSL_INCLUDE_DIR}
PRIVATE ${_gRPC_PROTOBUF_INCLUDE_DIR}
PRIVATE ${_gRPC_ZLIB_INCLUDE_DIR}
PRIVATE ${_gRPC_BENCHMARK_INCLUDE_DIR}
PRIVATE ${_gRPC_CARES_INCLUDE_DIR}
PRIVATE ${_gRPC_GFLAGS_INCLUDE_DIR}
PRIVATE ${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
)
target_link_libraries(h2_https_proxy_test
${_gRPC_ALLTARGETS_LIBRARIES}
end2end_tests
grpc_test_util
grpc
gpr_test_util
gpr
)
endif (gRPC_BUILD_TESTS)
if (gRPC_BUILD_TESTS)
add_executable(h2_load_reporting_test
test/core/end2end/fixtures/h2_load_reporting.cc
)

@ -1285,7 +1285,6 @@ h2_full+pipe_test: $(BINDIR)/$(CONFIG)/h2_full+pipe_test
h2_full+trace_test: $(BINDIR)/$(CONFIG)/h2_full+trace_test
h2_full+workarounds_test: $(BINDIR)/$(CONFIG)/h2_full+workarounds_test
h2_http_proxy_test: $(BINDIR)/$(CONFIG)/h2_http_proxy_test
h2_https_proxy_test: $(BINDIR)/$(CONFIG)/h2_https_proxy_test
h2_load_reporting_test: $(BINDIR)/$(CONFIG)/h2_load_reporting_test
h2_oauth2_test: $(BINDIR)/$(CONFIG)/h2_oauth2_test
h2_proxy_test: $(BINDIR)/$(CONFIG)/h2_proxy_test
@ -1540,7 +1539,6 @@ buildtests_c: privatelibs_c \
$(BINDIR)/$(CONFIG)/h2_full+trace_test \
$(BINDIR)/$(CONFIG)/h2_full+workarounds_test \
$(BINDIR)/$(CONFIG)/h2_http_proxy_test \
$(BINDIR)/$(CONFIG)/h2_https_proxy_test \
$(BINDIR)/$(CONFIG)/h2_load_reporting_test \
$(BINDIR)/$(CONFIG)/h2_oauth2_test \
$(BINDIR)/$(CONFIG)/h2_proxy_test \
@ -22818,38 +22816,6 @@ endif
endif
H2_HTTPS_PROXY_TEST_SRC = \
test/core/end2end/fixtures/h2_https_proxy.cc \
H2_HTTPS_PROXY_TEST_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(H2_HTTPS_PROXY_TEST_SRC))))
ifeq ($(NO_SECURE),true)
# You can't build secure targets if you don't have OpenSSL.
$(BINDIR)/$(CONFIG)/h2_https_proxy_test: openssl_dep_error
else
$(BINDIR)/$(CONFIG)/h2_https_proxy_test: $(H2_HTTPS_PROXY_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libend2end_tests.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a
$(E) "[LD] Linking $@"
$(Q) mkdir -p `dirname $@`
$(Q) $(LD) $(LDFLAGS) $(H2_HTTPS_PROXY_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libend2end_tests.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LDLIBS) $(LDLIBS_SECURE) -o $(BINDIR)/$(CONFIG)/h2_https_proxy_test
endif
$(OBJDIR)/$(CONFIG)/test/core/end2end/fixtures/h2_https_proxy.o: $(LIBDIR)/$(CONFIG)/libend2end_tests.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a
deps_h2_https_proxy_test: $(H2_HTTPS_PROXY_TEST_OBJS:.o=.dep)
ifneq ($(NO_SECURE),true)
ifneq ($(NO_DEPS),true)
-include $(H2_HTTPS_PROXY_TEST_OBJS:.o=.dep)
endif
endif
H2_LOAD_REPORTING_TEST_SRC = \
test/core/end2end/fixtures/h2_load_reporting.cc \

@ -34,34 +34,24 @@
#include "src/core/lib/gpr/env.h"
#include "src/core/lib/gpr/host_port.h"
#include "src/core/lib/gpr/string.h"
#include "src/core/lib/security/credentials/credentials.h"
#include "src/core/lib/slice/b64.h"
/**
* Parses the 'http_proxy' env var (or 'https_proxy', if it is a secure channel)
* and returns the proxy hostname to resolve or nullptr on error. Also sets
* 'user_cred' to user credentials if present in the 'http_proxy' env var,
* otherwise leaves it unchanged. It is caller's responsibility to gpr_free
* user_cred.
* Parses the 'https_proxy' env var (fallback on 'http_proxy') and returns the
* proxy hostname to resolve or nullptr on error. Also sets 'user_cred' to user
* credentials if present in the 'http_proxy' env var, otherwise leaves it
* unchanged. It is caller's responsibility to gpr_free user_cred.
*/
static char* get_http_proxy_server(char** user_cred,
const grpc_channel_args* args) {
static char* get_http_proxy_server(char** user_cred) {
GPR_ASSERT(user_cred != nullptr);
char* uri_str = nullptr;
/* Prefer using 'https_proxy' for secure channels and 'http_proxy' for
* insecure channels. Fallback on the other one if it is not set. The fallback
* behavior can be removed if there's a demand for it.
*/
if (grpc_channel_args_find(args, (char*)GRPC_ARG_CHANNEL_CREDENTIALS) !=
nullptr) {
uri_str = gpr_getenv("https_proxy");
if (uri_str == nullptr) gpr_getenv("http_proxy");
} else {
uri_str = gpr_getenv("http_proxy");
}
char* proxy_name = nullptr;
char** authority_strs = nullptr;
size_t authority_nstrs;
/* Prefer using 'https_proxy'. Fallback on 'http_proxy' if it is not set. The
* fallback behavior can be removed if there's a demand for it.
*/
char* uri_str = gpr_getenv("https_proxy");
if (uri_str == nullptr) uri_str = gpr_getenv("http_proxy");
if (uri_str == nullptr) return nullptr;
grpc_uri* uri = grpc_uri_parse(uri_str, false /* suppress_errors */);
if (uri == nullptr || uri->authority == nullptr) {
@ -116,7 +106,7 @@ static bool proxy_mapper_map_name(grpc_proxy_mapper* mapper,
return false;
}
char* user_cred = nullptr;
*name_to_resolve = get_http_proxy_server(&user_cred, args);
*name_to_resolve = get_http_proxy_server(&user_cred);
if (*name_to_resolve == nullptr) return false;
char* no_proxy_str = nullptr;
grpc_uri* uri = grpc_uri_parse(server_uri, false /* suppress_errors */);

@ -50,10 +50,7 @@ grpc_cc_library(
grpc_cc_library(
name = "http_proxy",
srcs = ["fixtures/http_proxy_fixture.cc"],
hdrs = [
"end2end_tests.h",
"fixtures/http_proxy_fixture.h"
],
hdrs = ["fixtures/http_proxy_fixture.h"],
language = "C++",
deps = [
"//:gpr",

@ -1,6 +1,6 @@
/*
*
* Copyright 2018 gRPC authors.
* Copyright 2016 gRPC authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -16,7 +16,7 @@
*
*/
/* This fixture runs the end to end tests with an http proxy in between. */
#include "test/core/end2end/end2end_tests.h"
#include <string.h>
@ -31,27 +31,63 @@
#include "src/core/lib/channel/connected_channel.h"
#include "src/core/lib/gpr/env.h"
#include "src/core/lib/gpr/host_port.h"
#include "src/core/lib/security/credentials/credentials.h"
#include "src/core/lib/surface/channel.h"
#include "src/core/lib/surface/server.h"
#include "test/core/end2end/data/ssl_test_data.h"
#include "test/core/end2end/fixtures/http_proxy_fixture.h"
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
static void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
grpc_channel_args* client_args) {
typedef struct fullstack_fixture_data {
char* server_addr;
grpc_end2end_http_proxy* proxy;
} fullstack_fixture_data;
static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
grpc_channel_args* client_args, grpc_channel_args* server_args) {
grpc_end2end_test_fixture f;
memset(&f, 0, sizeof(f));
fullstack_fixture_data* ffd = static_cast<fullstack_fixture_data*>(
gpr_malloc(sizeof(fullstack_fixture_data)));
const int server_port = grpc_pick_unused_port_or_die();
gpr_join_host_port(&ffd->server_addr, "localhost", server_port);
/* Passing client_args to proxy_create for the case of checking for proxy auth
*/
ffd->proxy = grpc_end2end_http_proxy_create(client_args);
f.fixture_data = ffd;
f.cq = grpc_completion_queue_create_for_next(nullptr);
f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
return f;
}
void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
grpc_channel_args* client_args) {
fullstack_fixture_data* ffd =
static_cast<fullstack_fixture_data*>(f->fixture_data);
set_http_proxy(grpc_end2end_http_proxy_get_proxy_name(ffd->proxy),
client_args, false);
char* proxy_uri;
/* If testing for proxy auth, add credentials to proxy uri */
const grpc_arg* proxy_auth_arg =
grpc_channel_args_find(client_args, GRPC_ARG_HTTP_PROXY_AUTH_CREDS);
const char* proxy_auth_str = grpc_channel_arg_get_string(proxy_auth_arg);
if (proxy_auth_str == nullptr) {
gpr_asprintf(&proxy_uri, "http://%s",
grpc_end2end_http_proxy_get_proxy_name(ffd->proxy));
} else {
gpr_asprintf(&proxy_uri, "http://%s@%s", proxy_auth_str,
grpc_end2end_http_proxy_get_proxy_name(ffd->proxy));
}
gpr_setenv("http_proxy", proxy_uri);
gpr_free(proxy_uri);
f->client =
grpc_insecure_channel_create(ffd->server_addr, client_args, nullptr);
GPR_ASSERT(f->client);
}
static void chttp2_init_server_fullstack(grpc_end2end_test_fixture* f,
grpc_channel_args* server_args) {
void chttp2_init_server_fullstack(grpc_end2end_test_fixture* f,
grpc_channel_args* server_args) {
fullstack_fixture_data* ffd =
static_cast<fullstack_fixture_data*>(f->fixture_data);
if (f->server) {
@ -63,6 +99,14 @@ static void chttp2_init_server_fullstack(grpc_end2end_test_fixture* f,
grpc_server_start(f->server);
}
void chttp2_tear_down_fullstack(grpc_end2end_test_fixture* f) {
fullstack_fixture_data* ffd =
static_cast<fullstack_fixture_data*>(f->fixture_data);
gpr_free(ffd->server_addr);
grpc_end2end_http_proxy_destroy(ffd->proxy);
gpr_free(ffd);
}
/* All test configurations */
static grpc_end2end_test_config configs[] = {
{"chttp2/fullstack",

@ -1,129 +0,0 @@
/*
*
* Copyright 2018 gRPC authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
/* This fixture runs end to end tests over a SSL connection with an http proxy.
*/
#include "test/core/end2end/end2end_tests.h"
#include <string.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include <grpc/support/string_util.h>
#include <grpc/support/sync.h>
#include "src/core/ext/filters/client_channel/client_channel.h"
#include "src/core/ext/filters/http/server/http_server_filter.h"
#include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
#include "src/core/lib/channel/connected_channel.h"
#include "src/core/lib/gpr/env.h"
#include "src/core/lib/gpr/host_port.h"
#include "src/core/lib/gpr/tmpfile.h"
#include "src/core/lib/security/credentials/credentials.h"
#include "src/core/lib/surface/channel.h"
#include "src/core/lib/surface/server.h"
#include "test/core/end2end/data/ssl_test_data.h"
#include "test/core/end2end/fixtures/http_proxy_fixture.h"
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
static void chttp2_init_client_secure_fullstack(
grpc_end2end_test_fixture* f, grpc_channel_args* client_args) {
grpc_core::ExecCtx exec_ctx;
fullstack_fixture_data* ffd =
static_cast<fullstack_fixture_data*>(f->fixture_data);
grpc_channel_credentials* ssl_creds =
grpc_ssl_credentials_create(nullptr, nullptr, nullptr);
grpc_arg ssl_name_override = {
GRPC_ARG_STRING,
const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
{const_cast<char*>("foo.test.google.fr")}};
grpc_channel_args* new_client_args =
grpc_channel_args_copy_and_add(client_args, &ssl_name_override, 1);
set_http_proxy(grpc_end2end_http_proxy_get_proxy_name(ffd->proxy),
client_args, true);
f->client = grpc_secure_channel_create(ssl_creds, ffd->server_addr,
new_client_args, nullptr);
GPR_ASSERT(f->client);
grpc_channel_credentials_release(ssl_creds);
grpc_channel_args_destroy(new_client_args);
}
static void chttp2_init_server_secure_fullstack(
grpc_end2end_test_fixture* f, grpc_channel_args* server_args) {
fullstack_fixture_data* ffd =
static_cast<fullstack_fixture_data*>(f->fixture_data);
if (f->server) {
grpc_server_destroy(f->server);
}
grpc_ssl_pem_key_cert_pair pem_cert_key_pair = {test_server1_key,
test_server1_cert};
grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
nullptr, &pem_cert_key_pair, 1, 0, nullptr);
f->server = grpc_server_create(server_args, nullptr);
grpc_server_register_completion_queue(f->server, f->cq, nullptr);
GPR_ASSERT(grpc_server_add_secure_http2_port(f->server, ffd->server_addr,
ssl_creds));
grpc_server_credentials_release(ssl_creds);
grpc_server_start(f->server);
}
/* All test configurations */
static grpc_end2end_test_config configs[] = {
{"chttp2/fullstack",
FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL |
FEATURE_MASK_SUPPORTS_AUTHORITY_HEADER,
"foo.test.google.fr", chttp2_create_fixture_fullstack,
chttp2_init_client_secure_fullstack, chttp2_init_server_secure_fullstack,
chttp2_tear_down_fullstack},
};
int main(int argc, char** argv) {
size_t i;
FILE* roots_file;
size_t roots_size = strlen(test_root_cert);
char* roots_filename;
grpc_test_init(argc, argv);
grpc_end2end_tests_pre_init();
/* Set the SSL roots env var. */
roots_file = gpr_tmpfile("chttp2_https_proxy_test", &roots_filename);
GPR_ASSERT(roots_filename != nullptr);
GPR_ASSERT(roots_file != nullptr);
GPR_ASSERT(fwrite(test_root_cert, 1, roots_size, roots_file) == roots_size);
fclose(roots_file);
gpr_setenv(GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR, roots_filename);
grpc_init();
for (i = 0; i < sizeof(configs) / sizeof(*configs); i++) {
grpc_end2end_tests(argc, argv, configs[i]);
}
grpc_shutdown();
/* Cleanup. */
remove(roots_filename);
gpr_free(roots_filename);
return 0;
}

@ -31,7 +31,6 @@
#include <grpc/support/sync.h>
#include "src/core/lib/channel/channel_args.h"
#include "src/core/lib/gpr/env.h"
#include "src/core/lib/gpr/host_port.h"
#include "src/core/lib/gpr/string.h"
#include "src/core/lib/gprpp/thd.h"
@ -581,51 +580,3 @@ const char* grpc_end2end_http_proxy_get_proxy_name(
grpc_end2end_http_proxy* proxy) {
return proxy->proxy_name;
}
grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
grpc_channel_args* client_args, grpc_channel_args* server_args) {
grpc_end2end_test_fixture f;
memset(&f, 0, sizeof(f));
fullstack_fixture_data* ffd = static_cast<fullstack_fixture_data*>(
gpr_malloc(sizeof(fullstack_fixture_data)));
const int server_port = grpc_pick_unused_port_or_die();
gpr_join_host_port(&ffd->server_addr, "localhost", server_port);
/* Passing client_args to proxy_create for the case of checking for proxy auth
*/
ffd->proxy = grpc_end2end_http_proxy_create(client_args);
f.fixture_data = ffd;
f.cq = grpc_completion_queue_create_for_next(nullptr);
f.shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
return f;
}
void set_http_proxy(const char* proxy_name,
const grpc_channel_args* client_args, bool secure) {
char* proxy_uri;
/* If testing for proxy auth, add credentials to proxy uri */
const grpc_arg* proxy_auth_arg =
grpc_channel_args_find(client_args, GRPC_ARG_HTTP_PROXY_AUTH_CREDS);
const char* proxy_auth_str = grpc_channel_arg_get_string(proxy_auth_arg);
if (proxy_auth_str == nullptr) {
gpr_asprintf(&proxy_uri, "http://%s", proxy_name);
} else {
gpr_asprintf(&proxy_uri, "http://%s@%s", proxy_auth_str, proxy_name);
}
if (secure) {
gpr_setenv("https_proxy", proxy_uri);
} else {
gpr_setenv("http_proxy", proxy_uri);
}
gpr_free(proxy_uri);
}
void chttp2_tear_down_fullstack(grpc_end2end_test_fixture* f) {
fullstack_fixture_data* ffd =
static_cast<fullstack_fixture_data*>(f->fixture_data);
gpr_free(ffd->server_addr);
grpc_end2end_http_proxy_destroy(ffd->proxy);
gpr_free(ffd);
}

@ -19,8 +19,6 @@
#ifndef GRPC_TEST_CORE_END2END_FIXTURES_HTTP_PROXY_FIXTURE_H
#define GRPC_TEST_CORE_END2END_FIXTURES_HTTP_PROXY_FIXTURE_H
#include "test/core/end2end/end2end_tests.h"
#include <grpc/grpc.h>
/* The test credentials being used for HTTP Proxy Authorization */
@ -34,14 +32,6 @@
typedef struct grpc_end2end_http_proxy grpc_end2end_http_proxy;
typedef struct fullstack_fixture_data {
char* server_addr;
grpc_end2end_http_proxy* proxy;
} fullstack_fixture_data;
/* These helper functions are common to h2_http_proxy and h2_https_proxy
* fixtures. */
grpc_end2end_http_proxy* grpc_end2end_http_proxy_create(
grpc_channel_args* args);
@ -50,13 +40,4 @@ void grpc_end2end_http_proxy_destroy(grpc_end2end_http_proxy* proxy);
const char* grpc_end2end_http_proxy_get_proxy_name(
grpc_end2end_http_proxy* proxy);
grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
grpc_channel_args* client_args, grpc_channel_args* server_args);
/* Sets 'http_proxy' if channel is insecure, otherwise sets 'https_proxy' */
void set_http_proxy(const char* proxy_name,
const grpc_channel_args* client_args, bool secure);
void chttp2_tear_down_fullstack(grpc_end2end_test_fixture* f);
#endif /* GRPC_TEST_CORE_END2END_FIXTURES_HTTP_PROXY_FIXTURE_H */

@ -57,8 +57,6 @@ END2END_FIXTURES = {
'h2_full+workarounds': default_unsecure_fixture_options,
'h2_http_proxy': default_unsecure_fixture_options._replace(
ci_mac=False, exclude_iomgrs=['uv'], supports_proxy_auth=True),
'h2_https_proxy': default_secure_fixture_options._replace(
ci_mac=False, exclude_iomgrs=['uv'], supports_proxy_auth=True),
'h2_oauth2': default_secure_fixture_options._replace(
ci_mac=False, exclude_iomgrs=['uv']),
'h2_proxy': default_unsecure_fixture_options._replace(

@ -55,7 +55,6 @@ END2END_FIXTURES = {
'h2_full+trace': fixture_options(tracing=True),
'h2_full+workarounds': fixture_options(),
'h2_http_proxy': fixture_options(supports_proxy_auth=True),
'h2_https_proxy': fixture_options(supports_proxy_auth=True, secure=True),
'h2_oauth2': fixture_options(),
'h2_proxy': fixture_options(includes_proxy=True),
'h2_sockpair_1byte': fixture_options(fullstack=False, dns_resolver=False,

@ -5971,24 +5971,6 @@
"third_party": false,
"type": "target"
},
{
"deps": [
"end2end_tests",
"gpr",
"gpr_test_util",
"grpc",
"grpc_test_util"
],
"headers": [],
"is_filegroup": false,
"language": "c",
"name": "h2_https_proxy_test",
"src": [
"test/core/end2end/fixtures/h2_https_proxy.cc"
],
"third_party": false,
"type": "target"
},
{
"deps": [
"end2end_tests",

File diff suppressed because it is too large Load Diff
Loading…
Cancel
Save