diff options
Diffstat (limited to 'test')
45 files changed, 1011 insertions, 147 deletions
diff --git a/test/core/end2end/dualstack_socket_test.c b/test/core/end2end/dualstack_socket_test.c index c98baeffda..48a88be525 100644 --- a/test/core/end2end/dualstack_socket_test.c +++ b/test/core/end2end/dualstack_socket_test.c @@ -131,8 +131,8 @@ void test_connect(const char *server_host, const char *client_host, int port, } /* Send a trivial request. */ - c = grpc_channel_create_call(client, cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(client, NULL, GRPC_PROPAGATE_DEFAULTS, cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); op = ops; diff --git a/test/core/end2end/fixtures/chttp2_fullstack_compression.c b/test/core/end2end/fixtures/chttp2_fullstack_compression.c index 0ee24c01b5..a75075d1d4 100644 --- a/test/core/end2end/fixtures/chttp2_fullstack_compression.c +++ b/test/core/end2end/fixtures/chttp2_fullstack_compression.c @@ -53,8 +53,8 @@ typedef struct fullstack_compression_fixture_data { char *localaddr; - grpc_channel_args* client_args_compression; - grpc_channel_args* server_args_compression; + grpc_channel_args *client_args_compression; + grpc_channel_args *server_args_compression; } fullstack_compression_fixture_data; static grpc_end2end_test_fixture chttp2_create_fixture_fullstack_compression( @@ -75,7 +75,7 @@ static grpc_end2end_test_fixture chttp2_create_fixture_fullstack_compression( } void chttp2_init_client_fullstack_compression(grpc_end2end_test_fixture *f, - grpc_channel_args *client_args) { + grpc_channel_args *client_args) { fullstack_compression_fixture_data *ffd = f->fixture_data; if (ffd->client_args_compression != NULL) { grpc_channel_args_destroy(ffd->client_args_compression); @@ -87,7 +87,7 @@ void chttp2_init_client_fullstack_compression(grpc_end2end_test_fixture *f, } void chttp2_init_server_fullstack_compression(grpc_end2end_test_fixture *f, - grpc_channel_args *server_args) { + grpc_channel_args *server_args) { fullstack_compression_fixture_data *ffd = f->fixture_data; if (ffd->server_args_compression != NULL) { grpc_channel_args_destroy(ffd->server_args_compression); diff --git a/test/core/end2end/fixtures/chttp2_fullstack_with_proxy.c b/test/core/end2end/fixtures/chttp2_fullstack_with_proxy.c new file mode 100644 index 0000000000..248cc7d6e7 --- /dev/null +++ b/test/core/end2end/fixtures/chttp2_fullstack_with_proxy.c @@ -0,0 +1,132 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include "test/core/end2end/end2end_tests.h" + +#include <string.h> + +#include "src/core/channel/client_channel.h" +#include "src/core/channel/connected_channel.h" +#include "src/core/channel/http_server_filter.h" +#include "src/core/surface/channel.h" +#include "src/core/surface/server.h" +#include "src/core/transport/chttp2_transport.h" +#include <grpc/support/alloc.h> +#include <grpc/support/host_port.h> +#include <grpc/support/log.h> +#include <grpc/support/sync.h> +#include <grpc/support/thd.h> +#include <grpc/support/useful.h> +#include "test/core/end2end/fixtures/proxy.h" +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" + +typedef struct fullstack_fixture_data { + grpc_end2end_proxy *proxy; +} fullstack_fixture_data; + +static grpc_server *create_proxy_server(const char *port) { + grpc_server *s = grpc_server_create(NULL); + GPR_ASSERT(grpc_server_add_insecure_http2_port(s, port)); + return s; +} + +static grpc_channel *create_proxy_client(const char *target) { + return grpc_insecure_channel_create(target, NULL); +} + +static const grpc_end2end_proxy_def proxy_def = {create_proxy_server, + create_proxy_client}; + +static grpc_end2end_test_fixture chttp2_create_fixture_fullstack( + grpc_channel_args *client_args, grpc_channel_args *server_args) { + grpc_end2end_test_fixture f; + fullstack_fixture_data *ffd = gpr_malloc(sizeof(fullstack_fixture_data)); + memset(&f, 0, sizeof(f)); + + ffd->proxy = grpc_end2end_proxy_create(&proxy_def); + + f.fixture_data = ffd; + f.cq = grpc_completion_queue_create(); + + return f; +} + +void chttp2_init_client_fullstack(grpc_end2end_test_fixture *f, + grpc_channel_args *client_args) { + fullstack_fixture_data *ffd = f->fixture_data; + f->client = grpc_insecure_channel_create( + grpc_end2end_proxy_get_client_target(ffd->proxy), client_args); + GPR_ASSERT(f->client); +} + +void chttp2_init_server_fullstack(grpc_end2end_test_fixture *f, + grpc_channel_args *server_args) { + fullstack_fixture_data *ffd = f->fixture_data; + if (f->server) { + grpc_server_destroy(f->server); + } + f->server = grpc_server_create(server_args); + grpc_server_register_completion_queue(f->server, f->cq); + GPR_ASSERT(grpc_server_add_insecure_http2_port( + f->server, grpc_end2end_proxy_get_server_port(ffd->proxy))); + grpc_server_start(f->server); +} + +void chttp2_tear_down_fullstack(grpc_end2end_test_fixture *f) { + fullstack_fixture_data *ffd = f->fixture_data; + grpc_end2end_proxy_destroy(ffd->proxy); + gpr_free(ffd); +} + +/* All test configurations */ +static grpc_end2end_test_config configs[] = { + {"chttp2/fullstack+proxy", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION, + chttp2_create_fixture_fullstack, chttp2_init_client_fullstack, + chttp2_init_server_fullstack, chttp2_tear_down_fullstack}, +}; + +int main(int argc, char **argv) { + size_t i; + + grpc_test_init(argc, argv); + grpc_init(); + + for (i = 0; i < sizeof(configs) / sizeof(*configs); i++) { + grpc_end2end_tests(configs[i]); + } + + grpc_shutdown(); + + return 0; +} diff --git a/test/core/end2end/fixtures/chttp2_simple_ssl_fullstack_with_proxy.c b/test/core/end2end/fixtures/chttp2_simple_ssl_fullstack_with_proxy.c new file mode 100644 index 0000000000..46a64de6c5 --- /dev/null +++ b/test/core/end2end/fixtures/chttp2_simple_ssl_fullstack_with_proxy.c @@ -0,0 +1,193 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include "test/core/end2end/end2end_tests.h" + +#include <stdio.h> +#include <string.h> + +#include "src/core/channel/channel_args.h" +#include "src/core/security/credentials.h" +#include "src/core/support/env.h" +#include "src/core/support/file.h" +#include "src/core/support/string.h" +#include <grpc/support/alloc.h> +#include <grpc/support/host_port.h> +#include <grpc/support/log.h> +#include "test/core/end2end/data/ssl_test_data.h" +#include "test/core/end2end/fixtures/proxy.h" +#include "test/core/util/test_config.h" +#include "test/core/util/port.h" + +typedef struct fullstack_secure_fixture_data { + grpc_end2end_proxy *proxy; +} fullstack_secure_fixture_data; + +static grpc_server *create_proxy_server(const char *port) { + grpc_server *s = grpc_server_create(NULL); + 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(NULL, &pem_cert_key_pair, 1, 0); + GPR_ASSERT(grpc_server_add_secure_http2_port(s, port, ssl_creds)); + grpc_server_credentials_release(ssl_creds); + return s; +} + +static grpc_channel *create_proxy_client(const char *target) { + grpc_channel *channel; + grpc_credentials *ssl_creds = grpc_ssl_credentials_create(NULL, NULL); + grpc_arg ssl_name_override = {GRPC_ARG_STRING, + GRPC_SSL_TARGET_NAME_OVERRIDE_ARG, + {"foo.test.google.fr"}}; + grpc_channel_args client_args; + client_args.num_args = 1; + client_args.args = &ssl_name_override; + channel = grpc_secure_channel_create(ssl_creds, target, &client_args); + grpc_credentials_release(ssl_creds); + return channel; +} + +static const grpc_end2end_proxy_def proxy_def = {create_proxy_server, + create_proxy_client}; + +static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack( + grpc_channel_args *client_args, grpc_channel_args *server_args) { + grpc_end2end_test_fixture f; + fullstack_secure_fixture_data *ffd = + gpr_malloc(sizeof(fullstack_secure_fixture_data)); + memset(&f, 0, sizeof(f)); + + ffd->proxy = grpc_end2end_proxy_create(&proxy_def); + + f.fixture_data = ffd; + f.cq = grpc_completion_queue_create(); + + return f; +} + +static void chttp2_init_client_secure_fullstack(grpc_end2end_test_fixture *f, + grpc_channel_args *client_args, + grpc_credentials *creds) { + fullstack_secure_fixture_data *ffd = f->fixture_data; + f->client = grpc_secure_channel_create( + creds, grpc_end2end_proxy_get_client_target(ffd->proxy), client_args); + GPR_ASSERT(f->client != NULL); + grpc_credentials_release(creds); +} + +static void chttp2_init_server_secure_fullstack( + grpc_end2end_test_fixture *f, grpc_channel_args *server_args, + grpc_server_credentials *server_creds) { + fullstack_secure_fixture_data *ffd = f->fixture_data; + if (f->server) { + grpc_server_destroy(f->server); + } + f->server = grpc_server_create(server_args); + grpc_server_register_completion_queue(f->server, f->cq); + GPR_ASSERT(grpc_server_add_secure_http2_port( + f->server, grpc_end2end_proxy_get_server_port(ffd->proxy), server_creds)); + grpc_server_credentials_release(server_creds); + grpc_server_start(f->server); +} + +void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) { + fullstack_secure_fixture_data *ffd = f->fixture_data; + grpc_end2end_proxy_destroy(ffd->proxy); + gpr_free(ffd); +} + +static void chttp2_init_client_simple_ssl_secure_fullstack( + grpc_end2end_test_fixture *f, grpc_channel_args *client_args) { + grpc_credentials *ssl_creds = grpc_ssl_credentials_create(NULL, NULL); + grpc_arg ssl_name_override = {GRPC_ARG_STRING, + GRPC_SSL_TARGET_NAME_OVERRIDE_ARG, + {"foo.test.google.fr"}}; + grpc_channel_args *new_client_args = + grpc_channel_args_copy_and_add(client_args, &ssl_name_override, 1); + chttp2_init_client_secure_fullstack(f, new_client_args, ssl_creds); + grpc_channel_args_destroy(new_client_args); +} + +static void chttp2_init_server_simple_ssl_secure_fullstack( + grpc_end2end_test_fixture *f, grpc_channel_args *server_args) { + 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(NULL, &pem_cert_key_pair, 1, 0); + chttp2_init_server_secure_fullstack(f, server_args, ssl_creds); +} + +/* All test configurations */ + +static grpc_end2end_test_config configs[] = { + {"chttp2/simple_ssl_fullstack", + FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION | + FEATURE_MASK_SUPPORTS_HOSTNAME_VERIFICATION | + FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS, + chttp2_create_fixture_secure_fullstack, + chttp2_init_client_simple_ssl_secure_fullstack, + chttp2_init_server_simple_ssl_secure_fullstack, + chttp2_tear_down_secure_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); + + /* Set the SSL roots env var. */ + roots_file = gpr_tmpfile("chttp2_simple_ssl_fullstack_test", &roots_filename); + GPR_ASSERT(roots_filename != NULL); + GPR_ASSERT(roots_file != NULL); + 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(configs[i]); + } + + grpc_shutdown(); + + /* Cleanup. */ + remove(roots_filename); + gpr_free(roots_filename); + + return 0; +} diff --git a/test/core/end2end/fixtures/chttp2_socket_pair_with_grpc_trace.c b/test/core/end2end/fixtures/chttp2_socket_pair_with_grpc_trace.c index c59628b959..6d2361b783 100644 --- a/test/core/end2end/fixtures/chttp2_socket_pair_with_grpc_trace.c +++ b/test/core/end2end/fixtures/chttp2_socket_pair_with_grpc_trace.c @@ -148,6 +148,7 @@ int main(int argc, char **argv) { /* force tracing on, with a value to force many code paths in trace.c to be taken */ gpr_setenv("GRPC_TRACE", "doesnt-exist,http,all"); + g_fixture_slowdown_factor = 10.0; grpc_test_init(argc, argv); grpc_init(); diff --git a/test/core/end2end/fixtures/proxy.c b/test/core/end2end/fixtures/proxy.c new file mode 100644 index 0000000000..e4f6263334 --- /dev/null +++ b/test/core/end2end/fixtures/proxy.c @@ -0,0 +1,430 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include "test/core/end2end/fixtures/proxy.h" + +#include <string.h> + +#include <grpc/support/alloc.h> +#include <grpc/support/host_port.h> +#include <grpc/support/log.h> +#include <grpc/support/sync.h> +#include <grpc/support/thd.h> +#include <grpc/support/useful.h> + +#include "test/core/util/port.h" + +struct grpc_end2end_proxy { + gpr_thd_id thd; + char *proxy_port; + char *server_port; + grpc_completion_queue *cq; + grpc_server *server; + grpc_channel *client; + + int shutdown; + + /* requested call */ + grpc_call *new_call; + grpc_call_details new_call_details; + grpc_metadata_array new_call_metadata; +}; + +typedef struct { + void (*func)(void *arg, int success); + void *arg; +} closure; + +typedef struct { + gpr_refcount refs; + grpc_end2end_proxy *proxy; + + grpc_call *c2p; + grpc_call *p2s; + + grpc_metadata_array c2p_initial_metadata; + grpc_metadata_array p2s_initial_metadata; + + grpc_byte_buffer *c2p_msg; + grpc_byte_buffer *p2s_msg; + + grpc_metadata_array p2s_trailing_metadata; + grpc_status_code p2s_status; + char *p2s_status_details; + size_t p2s_status_details_capacity; + + int c2p_server_cancelled; +} proxy_call; + +static void thread_main(void *arg); +static void request_call(grpc_end2end_proxy *proxy); + +grpc_end2end_proxy *grpc_end2end_proxy_create( + const grpc_end2end_proxy_def *def) { + gpr_thd_options opt = gpr_thd_options_default(); + int proxy_port = grpc_pick_unused_port_or_die(); + int server_port = grpc_pick_unused_port_or_die(); + + grpc_end2end_proxy *proxy = gpr_malloc(sizeof(*proxy)); + memset(proxy, 0, sizeof(*proxy)); + + gpr_join_host_port(&proxy->proxy_port, "localhost", proxy_port); + gpr_join_host_port(&proxy->server_port, "localhost", server_port); + proxy->cq = grpc_completion_queue_create(); + proxy->server = def->create_server(proxy->proxy_port); + proxy->client = def->create_client(proxy->server_port); + + grpc_server_register_completion_queue(proxy->server, proxy->cq); + grpc_server_start(proxy->server); + + gpr_thd_options_set_joinable(&opt); + GPR_ASSERT(gpr_thd_new(&proxy->thd, thread_main, proxy, &opt)); + + request_call(proxy); + + return proxy; +} + +static closure *new_closure(void (*func)(void *arg, int success), void *arg) { + closure *cl = gpr_malloc(sizeof(*cl)); + cl->func = func; + cl->arg = arg; + return cl; +} + +static void shutdown_complete(void *arg, int success) { + grpc_end2end_proxy *proxy = arg; + proxy->shutdown = 1; + grpc_completion_queue_shutdown(proxy->cq); +} + +void grpc_end2end_proxy_destroy(grpc_end2end_proxy *proxy) { + grpc_server_shutdown_and_notify(proxy->server, proxy->cq, + new_closure(shutdown_complete, proxy)); + gpr_thd_join(proxy->thd); + gpr_free(proxy->proxy_port); + gpr_free(proxy->server_port); + grpc_server_destroy(proxy->server); + grpc_channel_destroy(proxy->client); + grpc_completion_queue_destroy(proxy->cq); + grpc_call_details_destroy(&proxy->new_call_details); + gpr_free(proxy); +} + +static void unrefpc(proxy_call *pc, const char *reason) { + gpr_log(GPR_DEBUG, "unref %p: %s %d -> %d", pc, reason, pc->refs.count, + pc->refs.count - 1); + if (gpr_unref(&pc->refs)) { + grpc_call_destroy(pc->c2p); + grpc_call_destroy(pc->p2s); + grpc_metadata_array_destroy(&pc->c2p_initial_metadata); + grpc_metadata_array_destroy(&pc->p2s_initial_metadata); + grpc_metadata_array_destroy(&pc->p2s_trailing_metadata); + gpr_free(pc->p2s_status_details); + gpr_free(pc); + } +} + +static void refpc(proxy_call *pc, const char *reason) { + gpr_log(GPR_DEBUG, "ref %p: %s %d -> %d", pc, reason, pc->refs.count, + pc->refs.count + 1); + gpr_ref(&pc->refs); +} + +static void on_c2p_sent_initial_metadata(void *arg, int success) { + proxy_call *pc = arg; + unrefpc(pc, "on_c2p_sent_initial_metadata"); +} + +static void on_p2s_recv_initial_metadata(void *arg, int success) { + proxy_call *pc = arg; + grpc_op op; + grpc_call_error err; + + if (!pc->proxy->shutdown) { + op.op = GRPC_OP_SEND_INITIAL_METADATA; + op.flags = 0; + op.data.send_initial_metadata.count = pc->p2s_initial_metadata.count; + op.data.send_initial_metadata.metadata = pc->p2s_initial_metadata.metadata; + refpc(pc, "on_c2p_sent_initial_metadata"); + err = grpc_call_start_batch(pc->c2p, &op, 1, + new_closure(on_c2p_sent_initial_metadata, pc)); + GPR_ASSERT(err == GRPC_CALL_OK); + } + + unrefpc(pc, "on_p2s_recv_initial_metadata"); +} + +static void on_p2s_sent_initial_metadata(void *arg, int success) { + proxy_call *pc = arg; + unrefpc(pc, "on_p2s_sent_initial_metadata"); +} + +static void on_c2p_recv_msg(void *arg, int success); + +static void on_p2s_sent_message(void *arg, int success) { + proxy_call *pc = arg; + grpc_op op; + grpc_call_error err; + + grpc_byte_buffer_destroy(pc->c2p_msg); + if (!pc->proxy->shutdown && success) { + op.op = GRPC_OP_RECV_MESSAGE; + op.flags = 0; + op.data.recv_message = &pc->c2p_msg; + refpc(pc, "on_c2p_recv_msg"); + err = grpc_call_start_batch(pc->c2p, &op, 1, + new_closure(on_c2p_recv_msg, pc)); + GPR_ASSERT(err == GRPC_CALL_OK); + } + + unrefpc(pc, "on_p2s_sent_message"); +} + +static void on_p2s_sent_close(void *arg, int success) { + proxy_call *pc = arg; + unrefpc(pc, "on_p2s_sent_close"); +} + +static void on_c2p_recv_msg(void *arg, int success) { + proxy_call *pc = arg; + grpc_op op; + grpc_call_error err; + + if (!pc->proxy->shutdown && success) { + if (pc->c2p_msg != NULL) { + op.op = GRPC_OP_SEND_MESSAGE; + op.flags = 0; + op.data.send_message = pc->c2p_msg; + refpc(pc, "on_p2s_sent_message"); + err = grpc_call_start_batch(pc->p2s, &op, 1, + new_closure(on_p2s_sent_message, pc)); + GPR_ASSERT(err == GRPC_CALL_OK); + } else { + op.op = GRPC_OP_SEND_CLOSE_FROM_CLIENT; + op.flags = 0; + refpc(pc, "on_p2s_sent_close"); + err = grpc_call_start_batch(pc->p2s, &op, 1, + new_closure(on_p2s_sent_close, pc)); + GPR_ASSERT(err == GRPC_CALL_OK); + } + } + + unrefpc(pc, "on_c2p_recv_msg"); +} + +static void on_p2s_recv_msg(void *arg, int success); + +static void on_c2p_sent_message(void *arg, int success) { + proxy_call *pc = arg; + grpc_op op; + grpc_call_error err; + + grpc_byte_buffer_destroy(pc->p2s_msg); + if (!pc->proxy->shutdown && success) { + op.op = GRPC_OP_RECV_MESSAGE; + op.flags = 0; + op.data.recv_message = &pc->p2s_msg; + refpc(pc, "on_p2s_recv_msg"); + err = grpc_call_start_batch(pc->p2s, &op, 1, + new_closure(on_p2s_recv_msg, pc)); + GPR_ASSERT(err == GRPC_CALL_OK); + } + + unrefpc(pc, "on_c2p_sent_message"); +} + +static void on_p2s_recv_msg(void *arg, int success) { + proxy_call *pc = arg; + grpc_op op; + grpc_call_error err; + + if (!pc->proxy->shutdown && success && pc->p2s_msg) { + op.op = GRPC_OP_SEND_MESSAGE; + op.flags = 0; + op.data.send_message = pc->p2s_msg; + refpc(pc, "on_c2p_sent_message"); + err = grpc_call_start_batch(pc->c2p, &op, 1, + new_closure(on_c2p_sent_message, pc)); + GPR_ASSERT(err == GRPC_CALL_OK); + } + unrefpc(pc, "on_p2s_recv_msg"); +} + +static void on_c2p_sent_status(void *arg, int success) { + proxy_call *pc = arg; + unrefpc(pc, "on_c2p_sent_status"); +} + +static void on_p2s_status(void *arg, int success) { + proxy_call *pc = arg; + grpc_op op; + grpc_call_error err; + + if (!pc->proxy->shutdown) { + GPR_ASSERT(success); + op.op = GRPC_OP_SEND_STATUS_FROM_SERVER; + op.flags = 0; + op.data.send_status_from_server.trailing_metadata_count = + pc->p2s_trailing_metadata.count; + op.data.send_status_from_server.trailing_metadata = + pc->p2s_trailing_metadata.metadata; + op.data.send_status_from_server.status = pc->p2s_status; + op.data.send_status_from_server.status_details = pc->p2s_status_details; + refpc(pc, "on_c2p_sent_status"); + err = grpc_call_start_batch(pc->c2p, &op, 1, + new_closure(on_c2p_sent_status, pc)); + GPR_ASSERT(err == GRPC_CALL_OK); + } + + unrefpc(pc, "on_p2s_status"); +} + +static void on_c2p_closed(void *arg, int success) { + proxy_call *pc = arg; + unrefpc(pc, "on_c2p_closed"); +} + +static void on_new_call(void *arg, int success) { + grpc_end2end_proxy *proxy = arg; + grpc_call_error err; + + if (success) { + grpc_op op; + proxy_call *pc = gpr_malloc(sizeof(*pc)); + memset(pc, 0, sizeof(*pc)); + pc->proxy = proxy; + GPR_SWAP(grpc_metadata_array, pc->c2p_initial_metadata, + proxy->new_call_metadata); + pc->c2p = proxy->new_call; + pc->p2s = grpc_channel_create_call( + proxy->client, pc->c2p, GRPC_PROPAGATE_DEFAULTS, proxy->cq, + proxy->new_call_details.method, proxy->new_call_details.host, + proxy->new_call_details.deadline); + gpr_ref_init(&pc->refs, 1); + + op.flags = 0; + + op.op = GRPC_OP_RECV_INITIAL_METADATA; + op.data.recv_initial_metadata = &pc->p2s_initial_metadata; + refpc(pc, "on_p2s_recv_initial_metadata"); + err = grpc_call_start_batch(pc->p2s, &op, 1, + new_closure(on_p2s_recv_initial_metadata, pc)); + GPR_ASSERT(err == GRPC_CALL_OK); + + op.op = GRPC_OP_SEND_INITIAL_METADATA; + op.data.send_initial_metadata.count = pc->c2p_initial_metadata.count; + op.data.send_initial_metadata.metadata = pc->c2p_initial_metadata.metadata; + refpc(pc, "on_p2s_sent_initial_metadata"); + err = grpc_call_start_batch(pc->p2s, &op, 1, + new_closure(on_p2s_sent_initial_metadata, pc)); + GPR_ASSERT(err == GRPC_CALL_OK); + + op.op = GRPC_OP_RECV_MESSAGE; + op.data.recv_message = &pc->c2p_msg; + refpc(pc, "on_c2p_recv_msg"); + err = grpc_call_start_batch(pc->c2p, &op, 1, + new_closure(on_c2p_recv_msg, pc)); + GPR_ASSERT(err == GRPC_CALL_OK); + + op.op = GRPC_OP_RECV_MESSAGE; + op.data.recv_message = &pc->p2s_msg; + refpc(pc, "on_p2s_recv_msg"); + err = grpc_call_start_batch(pc->p2s, &op, 1, + new_closure(on_p2s_recv_msg, pc)); + GPR_ASSERT(err == GRPC_CALL_OK); + + op.op = GRPC_OP_RECV_STATUS_ON_CLIENT; + op.data.recv_status_on_client.trailing_metadata = + &pc->p2s_trailing_metadata; + op.data.recv_status_on_client.status = &pc->p2s_status; + op.data.recv_status_on_client.status_details = &pc->p2s_status_details; + op.data.recv_status_on_client.status_details_capacity = + &pc->p2s_status_details_capacity; + refpc(pc, "on_p2s_status"); + err = + grpc_call_start_batch(pc->p2s, &op, 1, new_closure(on_p2s_status, pc)); + GPR_ASSERT(err == GRPC_CALL_OK); + + op.op = GRPC_OP_RECV_CLOSE_ON_SERVER; + op.data.recv_close_on_server.cancelled = &pc->c2p_server_cancelled; + refpc(pc, "on_c2p_closed"); + err = + grpc_call_start_batch(pc->c2p, &op, 1, new_closure(on_c2p_closed, pc)); + GPR_ASSERT(err == GRPC_CALL_OK); + + request_call(proxy); + + unrefpc(pc, "init"); + } else { + GPR_ASSERT(proxy->new_call == NULL); + } +} + +static void request_call(grpc_end2end_proxy *proxy) { + proxy->new_call = NULL; + GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call( + proxy->server, &proxy->new_call, + &proxy->new_call_details, + &proxy->new_call_metadata, proxy->cq, + proxy->cq, new_closure(on_new_call, proxy))); +} + +static void thread_main(void *arg) { + grpc_end2end_proxy *proxy = arg; + closure *cl; + for (;;) { + grpc_event ev = grpc_completion_queue_next( + proxy->cq, gpr_inf_future(GPR_CLOCK_MONOTONIC)); + switch (ev.type) { + case GRPC_QUEUE_TIMEOUT: + gpr_log(GPR_ERROR, "Should never reach here"); + abort(); + case GRPC_QUEUE_SHUTDOWN: + return; + case GRPC_OP_COMPLETE: + cl = ev.tag; + cl->func(cl->arg, ev.success); + gpr_free(cl); + break; + } + } +} + +const char *grpc_end2end_proxy_get_client_target(grpc_end2end_proxy *proxy) { + return proxy->proxy_port; +} + +const char *grpc_end2end_proxy_get_server_port(grpc_end2end_proxy *proxy) { + return proxy->server_port; +} diff --git a/test/core/end2end/fixtures/proxy.h b/test/core/end2end/fixtures/proxy.h new file mode 100644 index 0000000000..c1cf01d39a --- /dev/null +++ b/test/core/end2end/fixtures/proxy.h @@ -0,0 +1,55 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#ifndef GRPC_TEST_CORE_END2END_FIXTURES_PROXY_H +#define GRPC_TEST_CORE_END2END_FIXTURES_PROXY_H + +#include <grpc/grpc.h> + +/* proxy service for _with_proxy fixtures */ + +typedef struct grpc_end2end_proxy grpc_end2end_proxy; + +typedef struct grpc_end2end_proxy_def { + grpc_server *(*create_server)(const char *port); + grpc_channel *(*create_client)(const char *target); +} grpc_end2end_proxy_def; + +grpc_end2end_proxy *grpc_end2end_proxy_create( + const grpc_end2end_proxy_def *def); +void grpc_end2end_proxy_destroy(grpc_end2end_proxy *proxy); + +const char *grpc_end2end_proxy_get_client_target(grpc_end2end_proxy *proxy); +const char *grpc_end2end_proxy_get_server_port(grpc_end2end_proxy *proxy); + +#endif /* GRPC_TEST_CORE_END2END_FIXTURES_PROXY_H */ diff --git a/test/core/end2end/gen_build_json.py b/test/core/end2end/gen_build_json.py index 43ab09f57d..c6e869364c 100755 --- a/test/core/end2end/gen_build_json.py +++ b/test/core/end2end/gen_build_json.py @@ -36,30 +36,33 @@ import simplejson import collections -FixtureOptions = collections.namedtuple('FixtureOptions', 'fullstack dns_resolver secure platforms') -default_unsecure_fixture_options = FixtureOptions(True, True, False, ['windows', 'posix']) -socketpair_unsecure_fixture_options = FixtureOptions(False, False, False, ['windows', 'posix']) -default_secure_fixture_options = FixtureOptions(True, True, True, ['windows', 'posix']) +FixtureOptions = collections.namedtuple('FixtureOptions', 'fullstack includes_proxy dns_resolver secure platforms') +default_unsecure_fixture_options = FixtureOptions(True, False, True, False, ['windows', 'posix']) +socketpair_unsecure_fixture_options = default_unsecure_fixture_options._replace(fullstack=False, dns_resolver=False) +default_secure_fixture_options = default_unsecure_fixture_options._replace(secure=True) +uds_fixture_options = default_unsecure_fixture_options._replace(dns_resolver=False, platforms=['posix']) # maps fixture name to whether it requires the security library END2END_FIXTURES = { 'chttp2_fake_security': default_secure_fixture_options, - 'chttp2_fullstack_compression': default_unsecure_fixture_options, 'chttp2_fullstack': default_unsecure_fixture_options, - 'chttp2_fullstack_uds_posix': FixtureOptions(True, False, False, ['posix']), - 'chttp2_fullstack_uds_posix_with_poll': FixtureOptions(True, False, False, ['posix']), - 'chttp2_fullstack_with_poll': FixtureOptions(True, True, False, ['posix']), + 'chttp2_fullstack_compression': default_unsecure_fixture_options, + 'chttp2_fullstack_uds_posix': uds_fixture_options, + 'chttp2_fullstack_uds_posix_with_poll': uds_fixture_options, + 'chttp2_fullstack_with_poll': default_unsecure_fixture_options._replace(platforms=['posix']), + 'chttp2_fullstack_with_proxy': default_unsecure_fixture_options._replace(includes_proxy=True), 'chttp2_simple_ssl_fullstack': default_secure_fixture_options, - 'chttp2_simple_ssl_fullstack_with_poll': FixtureOptions(True, True, True, ['posix']), + 'chttp2_simple_ssl_fullstack_with_poll': default_secure_fixture_options._replace(platforms=['posix']), + 'chttp2_simple_ssl_fullstack_with_proxy': default_secure_fixture_options._replace(includes_proxy=True), 'chttp2_simple_ssl_with_oauth2_fullstack': default_secure_fixture_options, - 'chttp2_socket_pair_one_byte_at_a_time': socketpair_unsecure_fixture_options, 'chttp2_socket_pair': socketpair_unsecure_fixture_options, + 'chttp2_socket_pair_one_byte_at_a_time': socketpair_unsecure_fixture_options, 'chttp2_socket_pair_with_grpc_trace': socketpair_unsecure_fixture_options, } -TestOptions = collections.namedtuple('TestOptions', 'needs_fullstack needs_dns flaky secure') -default_test_options = TestOptions(False, False, False, False) -connectivity_test_options = TestOptions(True, False, False, False) +TestOptions = collections.namedtuple('TestOptions', 'needs_fullstack needs_dns proxyable flaky secure') +default_test_options = TestOptions(False, False, True, False, False) +connectivity_test_options = default_test_options._replace(needs_fullstack=True) # maps test names to options END2END_TESTS = { @@ -70,26 +73,26 @@ END2END_TESTS = { 'cancel_before_invoke': default_test_options, 'cancel_in_a_vacuum': default_test_options, 'census_simple_request': default_test_options, - 'channel_connectivity': connectivity_test_options, - 'default_host': TestOptions(True, True, False, False), + 'channel_connectivity': connectivity_test_options._replace(proxyable=False), + 'default_host': default_test_options._replace(needs_fullstack=True, needs_dns=True), 'disappearing_server': connectivity_test_options, 'early_server_shutdown_finishes_inflight_calls': default_test_options, 'early_server_shutdown_finishes_tags': default_test_options, 'empty_batch': default_test_options, 'graceful_server_shutdown': default_test_options, 'invoke_large_request': default_test_options, - 'max_concurrent_streams': default_test_options, + 'max_concurrent_streams': default_test_options._replace(proxyable=False), 'max_message_length': default_test_options, 'no_op': default_test_options, 'ping_pong_streaming': default_test_options, 'registered_call': default_test_options, 'request_response_with_binary_metadata_and_payload': default_test_options, 'request_response_with_metadata_and_payload': default_test_options, - 'request_response_with_payload_and_call_creds': TestOptions(needs_fullstack=False, needs_dns=False, flaky=False, secure=True), + 'request_response_with_payload_and_call_creds': default_test_options._replace(secure=True), 'request_response_with_payload': default_test_options, 'request_response_with_trailing_metadata_and_payload': default_test_options, - 'request_with_compressed_payload': default_test_options, - 'request_with_flags': default_test_options, + 'request_with_compressed_payload': default_test_options._replace(proxyable=False), + 'request_with_flags': default_test_options._replace(proxyable=False), 'request_with_large_metadata': default_test_options, 'request_with_payload': default_test_options, 'server_finishes_request': default_test_options, @@ -106,6 +109,9 @@ def compatible(f, t): if END2END_TESTS[t].needs_dns: if not END2END_FIXTURES[f].dns_resolver: return False + if not END2END_TESTS[t].proxyable: + if END2END_FIXTURES[f].includes_proxy: + return False return True diff --git a/test/core/end2end/no_server_test.c b/test/core/end2end/no_server_test.c index 6f1133c009..6a5e12325d 100644 --- a/test/core/end2end/no_server_test.c +++ b/test/core/end2end/no_server_test.c @@ -62,7 +62,8 @@ int main(int argc, char **argv) { /* create a call, channel to a non existant server */ chan = grpc_insecure_channel_create("nonexistant:54321", NULL); - call = grpc_channel_create_call(chan, cq, "/Foo", "nonexistant", deadline); + call = grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq, + "/Foo", "nonexistant", deadline); op = ops; op->op = GRPC_OP_SEND_INITIAL_METADATA; diff --git a/test/core/end2end/tests/bad_hostname.c b/test/core/end2end/tests/bad_hostname.c index 2509ea06a0..198ba46cd2 100644 --- a/test/core/end2end/tests/bad_hostname.c +++ b/test/core/end2end/tests/bad_hostname.c @@ -113,8 +113,8 @@ static void simple_request_body(grpc_end2end_test_fixture f) { char *details = NULL; size_t details_capacity = 0; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "slartibartfast.local", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "slartibartfast.local", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/cancel_after_accept.c b/test/core/end2end/tests/cancel_after_accept.c index 1cc6b2d147..2e166b8412 100644 --- a/test/core/end2end/tests/cancel_after_accept.c +++ b/test/core/end2end/tests/cancel_after_accept.c @@ -126,8 +126,8 @@ static void test_cancel_after_accept(grpc_end2end_test_config config, grpc_raw_byte_buffer_create(&response_payload_slice, 1); int was_cancelled = 2; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); @@ -192,8 +192,7 @@ static void test_cancel_after_accept(grpc_end2end_test_config config, cq_expect_completion(cqv, tag(1), 1); cq_verify(cqv); - GPR_ASSERT(status == mode.expect_status); - GPR_ASSERT(0 == strcmp(details, mode.expect_details)); + GPR_ASSERT(status == mode.expect_status || status == GRPC_STATUS_INTERNAL); GPR_ASSERT(was_cancelled == 1); grpc_metadata_array_destroy(&initial_metadata_recv); diff --git a/test/core/end2end/tests/cancel_after_accept_and_writes_closed.c b/test/core/end2end/tests/cancel_after_accept_and_writes_closed.c index 015d437543..171c1874cc 100644 --- a/test/core/end2end/tests/cancel_after_accept_and_writes_closed.c +++ b/test/core/end2end/tests/cancel_after_accept_and_writes_closed.c @@ -126,8 +126,8 @@ static void test_cancel_after_accept_and_writes_closed( grpc_raw_byte_buffer_create(&response_payload_slice, 1); int was_cancelled = 2; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); @@ -195,8 +195,7 @@ static void test_cancel_after_accept_and_writes_closed( cq_expect_completion(cqv, tag(1), 1); cq_verify(cqv); - GPR_ASSERT(status == mode.expect_status); - GPR_ASSERT(0 == strcmp(details, mode.expect_details)); + GPR_ASSERT(status == mode.expect_status || status == GRPC_STATUS_INTERNAL); GPR_ASSERT(was_cancelled == 1); grpc_metadata_array_destroy(&initial_metadata_recv); diff --git a/test/core/end2end/tests/cancel_after_invoke.c b/test/core/end2end/tests/cancel_after_invoke.c index 414ec706ce..186cd44a43 100644 --- a/test/core/end2end/tests/cancel_after_invoke.c +++ b/test/core/end2end/tests/cancel_after_invoke.c @@ -121,8 +121,8 @@ static void test_cancel_after_invoke(grpc_end2end_test_config config, grpc_byte_buffer *request_payload = grpc_raw_byte_buffer_create(&request_payload_slice, 1); - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); @@ -164,8 +164,7 @@ static void test_cancel_after_invoke(grpc_end2end_test_config config, cq_expect_completion(cqv, tag(1), 1); cq_verify(cqv); - GPR_ASSERT(status == mode.expect_status); - GPR_ASSERT(0 == strcmp(details, mode.expect_details)); + GPR_ASSERT(status == mode.expect_status || status == GRPC_STATUS_INTERNAL); grpc_metadata_array_destroy(&initial_metadata_recv); grpc_metadata_array_destroy(&trailing_metadata_recv); diff --git a/test/core/end2end/tests/cancel_before_invoke.c b/test/core/end2end/tests/cancel_before_invoke.c index 3cfe56eca2..b511908b4f 100644 --- a/test/core/end2end/tests/cancel_before_invoke.c +++ b/test/core/end2end/tests/cancel_before_invoke.c @@ -119,8 +119,8 @@ static void test_cancel_before_invoke(grpc_end2end_test_config config, grpc_byte_buffer *request_payload = grpc_raw_byte_buffer_create(&request_payload_slice, 1); - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); GPR_ASSERT(GRPC_CALL_OK == grpc_call_cancel(c)); diff --git a/test/core/end2end/tests/cancel_in_a_vacuum.c b/test/core/end2end/tests/cancel_in_a_vacuum.c index 8bffc3f4d3..7645410184 100644 --- a/test/core/end2end/tests/cancel_in_a_vacuum.c +++ b/test/core/end2end/tests/cancel_in_a_vacuum.c @@ -107,8 +107,8 @@ static void test_cancel_in_a_vacuum(grpc_end2end_test_config config, gpr_timespec deadline = five_seconds_time(); cq_verifier *v_client = cq_verifier_create(f.cq); - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c)); diff --git a/test/core/end2end/tests/census_simple_request.c b/test/core/end2end/tests/census_simple_request.c index b414755cd1..2142dde921 100644 --- a/test/core/end2end/tests/census_simple_request.c +++ b/test/core/end2end/tests/census_simple_request.c @@ -111,8 +111,8 @@ static void test_body(grpc_end2end_test_fixture f) { size_t details_capacity = 0; int was_cancelled = 2; - c = grpc_channel_create_call(f.client, f.cq, "/foo", - "foo.test.google.fr:1234", deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr:1234", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/default_host.c b/test/core/end2end/tests/default_host.c index 63ef4bcd35..920449f4fa 100644 --- a/test/core/end2end/tests/default_host.c +++ b/test/core/end2end/tests/default_host.c @@ -116,7 +116,8 @@ static void simple_request_body(grpc_end2end_test_fixture f) { int was_cancelled = 2; char *peer; - c = grpc_channel_create_call(f.client, f.cq, "/foo", NULL, deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", NULL, deadline); GPR_ASSERT(c); peer = grpc_call_get_peer(c); diff --git a/test/core/end2end/tests/disappearing_server.c b/test/core/end2end/tests/disappearing_server.c index a5fd74ee9a..94bed336e8 100644 --- a/test/core/end2end/tests/disappearing_server.c +++ b/test/core/end2end/tests/disappearing_server.c @@ -97,8 +97,8 @@ static void do_request_and_shutdown_server(grpc_end2end_test_fixture *f, size_t details_capacity = 0; int was_cancelled = 2; - c = grpc_channel_create_call(f->client, f->cq, "/foo", - "foo.test.google.fr:1234", deadline); + c = grpc_channel_create_call(f->client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq, + "/foo", "foo.test.google.fr:1234", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/early_server_shutdown_finishes_inflight_calls.c b/test/core/end2end/tests/early_server_shutdown_finishes_inflight_calls.c index adc59b4e94..36cbe8067b 100644 --- a/test/core/end2end/tests/early_server_shutdown_finishes_inflight_calls.c +++ b/test/core/end2end/tests/early_server_shutdown_finishes_inflight_calls.c @@ -105,8 +105,8 @@ static void test_early_server_shutdown_finishes_inflight_calls( size_t details_capacity = 0; int was_cancelled = 2; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/empty_batch.c b/test/core/end2end/tests/empty_batch.c index db8458d3d9..138c6b07c5 100644 --- a/test/core/end2end/tests/empty_batch.c +++ b/test/core/end2end/tests/empty_batch.c @@ -105,8 +105,8 @@ static void empty_batch_body(grpc_end2end_test_fixture f) { cq_verifier *cqv = cq_verifier_create(f.cq); grpc_op *op = NULL; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(c, op, 0, tag(1))); diff --git a/test/core/end2end/tests/graceful_server_shutdown.c b/test/core/end2end/tests/graceful_server_shutdown.c index 8c1889add9..23efa0304f 100644 --- a/test/core/end2end/tests/graceful_server_shutdown.c +++ b/test/core/end2end/tests/graceful_server_shutdown.c @@ -112,8 +112,8 @@ static void test_early_server_shutdown_finishes_inflight_calls( size_t details_capacity = 0; int was_cancelled = 2; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/invoke_large_request.c b/test/core/end2end/tests/invoke_large_request.c index 744a9ada57..e32645e2ba 100644 --- a/test/core/end2end/tests/invoke_large_request.c +++ b/test/core/end2end/tests/invoke_large_request.c @@ -128,8 +128,8 @@ static void test_invoke_large_request(grpc_end2end_test_config config) { size_t details_capacity = 0; int was_cancelled = 2; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/max_concurrent_streams.c b/test/core/end2end/tests/max_concurrent_streams.c index 1204c070af..049c028835 100644 --- a/test/core/end2end/tests/max_concurrent_streams.c +++ b/test/core/end2end/tests/max_concurrent_streams.c @@ -113,8 +113,8 @@ static void simple_request_body(grpc_end2end_test_fixture f) { size_t details_capacity = 0; int was_cancelled = 2; - c = grpc_channel_create_call(f.client, f.cq, "/foo", - "foo.test.google.fr:1234", deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr:1234", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); @@ -244,11 +244,11 @@ static void test_max_concurrent_streams(grpc_end2end_test_config config) { /* start two requests - ensuring that the second is not accepted until the first completes */ deadline = n_seconds_time(1000); - c1 = grpc_channel_create_call(f.client, f.cq, "/alpha", - "foo.test.google.fr:1234", deadline); + c1 = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/alpha", "foo.test.google.fr:1234", deadline); GPR_ASSERT(c1); - c2 = grpc_channel_create_call(f.client, f.cq, "/beta", - "foo.test.google.fr:1234", deadline); + c2 = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/beta", "foo.test.google.fr:1234", deadline); GPR_ASSERT(c2); GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call( diff --git a/test/core/end2end/tests/max_message_length.c b/test/core/end2end/tests/max_message_length.c index ea59a9385f..feea49c68f 100644 --- a/test/core/end2end/tests/max_message_length.c +++ b/test/core/end2end/tests/max_message_length.c @@ -128,8 +128,8 @@ static void test_max_message_length(grpc_end2end_test_config config) { f = begin_test(config, "test_max_message_length", NULL, &server_args); cqv = cq_verifier_create(f.cq); - c = grpc_channel_create_call(f.client, f.cq, "/foo", - "foo.test.google.fr:1234", + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr:1234", gpr_inf_future(GPR_CLOCK_REALTIME)); GPR_ASSERT(c); diff --git a/test/core/end2end/tests/ping_pong_streaming.c b/test/core/end2end/tests/ping_pong_streaming.c index 8a3ec96212..0ae611b518 100644 --- a/test/core/end2end/tests/ping_pong_streaming.c +++ b/test/core/end2end/tests/ping_pong_streaming.c @@ -124,8 +124,8 @@ static void test_pingpong_streaming(grpc_end2end_test_config config, gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world"); gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you"); - c = grpc_channel_create_call(f.client, f.cq, "/foo", - "foo.test.google.fr:1234", deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr:1234", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/registered_call.c b/test/core/end2end/tests/registered_call.c index f44fd3a224..ffc4cd40a0 100644 --- a/test/core/end2end/tests/registered_call.c +++ b/test/core/end2end/tests/registered_call.c @@ -115,7 +115,8 @@ static void simple_request_body(grpc_end2end_test_fixture f, void *rc) { size_t details_capacity = 0; int was_cancelled = 2; - c = grpc_channel_create_registered_call(f.client, f.cq, rc, deadline); + c = grpc_channel_create_registered_call( + f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, rc, deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/request_response_with_binary_metadata_and_payload.c b/test/core/end2end/tests/request_response_with_binary_metadata_and_payload.c index 8b8a11babe..600642e6a7 100644 --- a/test/core/end2end/tests/request_response_with_binary_metadata_and_payload.c +++ b/test/core/end2end/tests/request_response_with_binary_metadata_and_payload.c @@ -143,8 +143,8 @@ static void test_request_response_with_metadata_and_payload( size_t details_capacity = 0; int was_cancelled = 2; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/request_response_with_metadata_and_payload.c b/test/core/end2end/tests/request_response_with_metadata_and_payload.c index 9821d7852f..7e8cce10f4 100644 --- a/test/core/end2end/tests/request_response_with_metadata_and_payload.c +++ b/test/core/end2end/tests/request_response_with_metadata_and_payload.c @@ -129,8 +129,8 @@ static void test_request_response_with_metadata_and_payload( size_t details_capacity = 0; int was_cancelled = 2; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/request_response_with_payload.c b/test/core/end2end/tests/request_response_with_payload.c index 38d3432f94..55323895fb 100644 --- a/test/core/end2end/tests/request_response_with_payload.c +++ b/test/core/end2end/tests/request_response_with_payload.c @@ -121,8 +121,8 @@ static void request_response_with_payload(grpc_end2end_test_fixture f) { size_t details_capacity = 0; int was_cancelled = 2; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/request_response_with_payload_and_call_creds.c b/test/core/end2end/tests/request_response_with_payload_and_call_creds.c index b5c743b405..ba312d0d5c 100644 --- a/test/core/end2end/tests/request_response_with_payload_and_call_creds.c +++ b/test/core/end2end/tests/request_response_with_payload_and_call_creds.c @@ -130,8 +130,8 @@ static void test_call_creds_failure(grpc_end2end_test_config config) { grpc_end2end_test_fixture f = begin_test(config, "test_call_creds_failure", NULL, NULL); gpr_timespec deadline = five_seconds_time(); - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); /* Try with credentials unfit to be set on a call (channel creds). */ @@ -175,8 +175,8 @@ static void request_response_with_payload_and_call_creds( grpc_credentials *creds = NULL; grpc_auth_context *s_auth_context = NULL; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); creds = grpc_iam_credentials_create(iam_token, iam_selector); GPR_ASSERT(creds != NULL); diff --git a/test/core/end2end/tests/request_response_with_trailing_metadata_and_payload.c b/test/core/end2end/tests/request_response_with_trailing_metadata_and_payload.c index a5c0851d05..26be4ef643 100644 --- a/test/core/end2end/tests/request_response_with_trailing_metadata_and_payload.c +++ b/test/core/end2end/tests/request_response_with_trailing_metadata_and_payload.c @@ -131,8 +131,8 @@ static void test_request_response_with_metadata_and_payload( size_t details_capacity = 0; int was_cancelled = 2; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/request_with_compressed_payload.c b/test/core/end2end/tests/request_with_compressed_payload.c index 2599f796d2..5f7d83cb06 100644 --- a/test/core/end2end/tests/request_with_compressed_payload.c +++ b/test/core/end2end/tests/request_with_compressed_payload.c @@ -141,8 +141,8 @@ static void request_with_payload_template( f = begin_test(config, test_name, client_args, server_args); cqv = cq_verifier_create(f.cq); - c = grpc_channel_create_call(f.client, f.cq, "/foo", - "foo.test.google.fr", deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/request_with_flags.c b/test/core/end2end/tests/request_with_flags.c index 0bfedca0ab..37c4825c8b 100644 --- a/test/core/end2end/tests/request_with_flags.c +++ b/test/core/end2end/tests/request_with_flags.c @@ -121,8 +121,8 @@ static void test_invoke_request_with_flags( size_t details_capacity = 0; grpc_call_error expectation; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/request_with_large_metadata.c b/test/core/end2end/tests/request_with_large_metadata.c index ad34c69774..9ea8273ab0 100644 --- a/test/core/end2end/tests/request_with_large_metadata.c +++ b/test/core/end2end/tests/request_with_large_metadata.c @@ -122,8 +122,8 @@ static void test_request_with_large_metadata(grpc_end2end_test_config config) { int was_cancelled = 2; const int large_size = 64 * 1024; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); meta.key = "key"; diff --git a/test/core/end2end/tests/request_with_payload.c b/test/core/end2end/tests/request_with_payload.c index 8db6457830..6b5f173f01 100644 --- a/test/core/end2end/tests/request_with_payload.c +++ b/test/core/end2end/tests/request_with_payload.c @@ -120,8 +120,8 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) { size_t details_capacity = 0; int was_cancelled = 2; - c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/server_finishes_request.c b/test/core/end2end/tests/server_finishes_request.c index 062a59aca2..661c099d93 100644 --- a/test/core/end2end/tests/server_finishes_request.c +++ b/test/core/end2end/tests/server_finishes_request.c @@ -115,8 +115,8 @@ static void simple_request_body(grpc_end2end_test_fixture f) { size_t details_capacity = 0; int was_cancelled = 2; - c = grpc_channel_create_call(f.client, f.cq, "/foo", - "foo.test.google.fr:1234", deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr:1234", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/simple_delayed_request.c b/test/core/end2end/tests/simple_delayed_request.c index 034e974256..82d2bf9657 100644 --- a/test/core/end2end/tests/simple_delayed_request.c +++ b/test/core/end2end/tests/simple_delayed_request.c @@ -107,8 +107,8 @@ static void simple_delayed_request_body(grpc_end2end_test_config config, config.init_client(f, client_args); - c = grpc_channel_create_call(f->client, f->cq, "/foo", "foo.test.google.fr", - deadline); + c = grpc_channel_create_call(f->client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq, + "/foo", "foo.test.google.fr", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/end2end/tests/simple_request.c b/test/core/end2end/tests/simple_request.c index ca783afccd..d60a63e682 100644 --- a/test/core/end2end/tests/simple_request.c +++ b/test/core/end2end/tests/simple_request.c @@ -116,8 +116,8 @@ static void simple_request_body(grpc_end2end_test_fixture f) { int was_cancelled = 2; char *peer; - c = grpc_channel_create_call(f.client, f.cq, "/foo", - "foo.test.google.fr:1234", deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr:1234", deadline); GPR_ASSERT(c); peer = grpc_call_get_peer(c); diff --git a/test/core/end2end/tests/simple_request_with_high_initial_sequence_number.c b/test/core/end2end/tests/simple_request_with_high_initial_sequence_number.c index 2cd638cbb9..2244e22416 100644 --- a/test/core/end2end/tests/simple_request_with_high_initial_sequence_number.c +++ b/test/core/end2end/tests/simple_request_with_high_initial_sequence_number.c @@ -115,8 +115,8 @@ static void simple_request_body(grpc_end2end_test_fixture f) { size_t details_capacity = 0; int was_cancelled = 2; - c = grpc_channel_create_call(f.client, f.cq, "/foo", - "foo.test.google.fr:1234", deadline); + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr:1234", deadline); GPR_ASSERT(c); grpc_metadata_array_init(&initial_metadata_recv); diff --git a/test/core/fling/client.c b/test/core/fling/client.c index 5647a16101..17b737c9dd 100644 --- a/test/core/fling/client.c +++ b/test/core/fling/client.c @@ -89,9 +89,9 @@ static void init_ping_pong_request(void) { } static void step_ping_pong_request(void) { - call = - grpc_channel_create_call(channel, cq, "/Reflector/reflectUnary", - "localhost", gpr_inf_future(GPR_CLOCK_REALTIME)); + call = grpc_channel_create_call(channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq, + "/Reflector/reflectUnary", "localhost", + gpr_inf_future(GPR_CLOCK_REALTIME)); GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call, ops, op - ops, (void *)1)); grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME)); @@ -101,9 +101,9 @@ static void step_ping_pong_request(void) { } static void init_ping_pong_stream(void) { - call = - grpc_channel_create_call(channel, cq, "/Reflector/reflectStream", - "localhost", gpr_inf_future(GPR_CLOCK_REALTIME)); + call = grpc_channel_create_call(channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq, + "/Reflector/reflectStream", "localhost", + gpr_inf_future(GPR_CLOCK_REALTIME)); stream_init_op.op = GRPC_OP_SEND_INITIAL_METADATA; stream_init_op.data.send_initial_metadata.count = 0; GPR_ASSERT(GRPC_CALL_OK == diff --git a/test/core/surface/lame_client_test.c b/test/core/surface/lame_client_test.c index 3a7a3a36ee..5e6c9ae15c 100644 --- a/test/core/surface/lame_client_test.c +++ b/test/core/surface/lame_client_test.c @@ -60,7 +60,8 @@ int main(int argc, char **argv) { chan = grpc_lame_client_channel_create("lampoon:national"); GPR_ASSERT(chan); cq = grpc_completion_queue_create(); - call = grpc_channel_create_call(chan, cq, "/Foo", "anywhere", + call = grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq, + "/Foo", "anywhere", GRPC_TIMEOUT_SECONDS_TO_DEADLINE(100)); GPR_ASSERT(call); cqv = cq_verifier_create(cq); diff --git a/test/core/util/reconnect_server.c b/test/core/util/reconnect_server.c index 74a8d44259..2a2113338b 100644 --- a/test/core/util/reconnect_server.c +++ b/test/core/util/reconnect_server.c @@ -129,11 +129,12 @@ void reconnect_server_start(reconnect_server *server, int port) { } void reconnect_server_poll(reconnect_server *server, int seconds) { + grpc_pollset_worker worker; gpr_timespec deadline = gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), gpr_time_from_seconds(seconds, GPR_TIMESPAN)); gpr_mu_lock(GRPC_POLLSET_MU(&server->pollset)); - grpc_pollset_work(&server->pollset, deadline); + grpc_pollset_work(&server->pollset, &worker, deadline); gpr_mu_unlock(GRPC_POLLSET_MU(&server->pollset)); } diff --git a/test/core/util/test_config.c b/test/core/util/test_config.c index 225658f5e2..cadf88a7c6 100644 --- a/test/core/util/test_config.c +++ b/test/core/util/test_config.c @@ -38,6 +38,8 @@ #include <stdlib.h> #include <signal.h> +double g_fixture_slowdown_factor = 1.0; + #if GPR_GETPID_IN_UNISTD_H #include <unistd.h> static int seed(void) { return getpid(); } diff --git a/test/core/util/test_config.h b/test/core/util/test_config.h index 7028ade7b2..b2cc40bb47 100644 --- a/test/core/util/test_config.h +++ b/test/core/util/test_config.h @@ -48,8 +48,11 @@ extern "C" { #define GRPC_TEST_SLOWDOWN_MACHINE_FACTOR 1.0 #endif -#define GRPC_TEST_SLOWDOWN_FACTOR \ - (GRPC_TEST_SLOWDOWN_BUILD_FACTOR * GRPC_TEST_SLOWDOWN_MACHINE_FACTOR) +extern double g_fixture_slowdown_factor; + +#define GRPC_TEST_SLOWDOWN_FACTOR \ + (GRPC_TEST_SLOWDOWN_BUILD_FACTOR * GRPC_TEST_SLOWDOWN_MACHINE_FACTOR * \ + g_fixture_slowdown_factor) #define GRPC_TIMEOUT_SECONDS_TO_DEADLINE(x) \ gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), \ diff --git a/test/cpp/end2end/end2end_test.cc b/test/cpp/end2end/end2end_test.cc index 3144ca4dc7..24d417d9e6 100644 --- a/test/cpp/end2end/end2end_test.cc +++ b/test/cpp/end2end/end2end_test.cc @@ -104,6 +104,22 @@ bool CheckIsLocalhost(const grpc::string& addr) { } // namespace +class Proxy : public ::grpc::cpp::test::util::TestService::Service { + public: + Proxy(std::shared_ptr<ChannelInterface> channel) + : stub_(grpc::cpp::test::util::TestService::NewStub(channel)) {} + + Status Echo(ServerContext* server_context, const EchoRequest* request, + EchoResponse* response) GRPC_OVERRIDE { + std::unique_ptr<ClientContext> client_context = + ClientContext::FromServerContext(*server_context); + return stub_->Echo(client_context.get(), *request, response); + } + + private: + std::unique_ptr<::grpc::cpp::test::util::TestService::Stub> stub_; +}; + class TestServiceImpl : public ::grpc::cpp::test::util::TestService::Service { public: TestServiceImpl() : signal_client_(false), host_() {} @@ -241,7 +257,9 @@ class TestServiceImplDupPkg } }; -class End2endTest : public ::testing::Test { +/* Param is whether or not to use a proxy -- some tests use TEST_F as they don't + need this functionality */ +class End2endTest : public ::testing::TestWithParam<bool> { protected: End2endTest() : kMaxMessageSize_(8192), special_service_("special"), thread_pool_(2) {} @@ -267,21 +285,41 @@ class End2endTest : public ::testing::Test { server_ = builder.BuildAndStart(); } - void TearDown() GRPC_OVERRIDE { server_->Shutdown(); } + void TearDown() GRPC_OVERRIDE { + server_->Shutdown(); + if (proxy_server_) proxy_server_->Shutdown(); + } - void ResetStub() { + void ResetStub(bool use_proxy) { SslCredentialsOptions ssl_opts = {test_root_cert, "", ""}; ChannelArguments args; args.SetSslTargetNameOverride("foo.test.google.fr"); args.SetString(GRPC_ARG_SECONDARY_USER_AGENT_STRING, "end2end_test"); channel_ = CreateChannel(server_address_.str(), SslCredentials(ssl_opts), args); + if (use_proxy) { + proxy_service_.reset(new Proxy(channel_)); + int port = grpc_pick_unused_port_or_die(); + std::ostringstream proxyaddr; + proxyaddr << "localhost:" << port; + ServerBuilder builder; + builder.AddListeningPort(proxyaddr.str(), InsecureServerCredentials()); + builder.RegisterService(proxy_service_.get()); + builder.SetThreadPool(&thread_pool_); + proxy_server_ = builder.BuildAndStart(); + + channel_ = CreateChannel(proxyaddr.str(), InsecureCredentials(), + ChannelArguments()); + } + stub_ = std::move(grpc::cpp::test::util::TestService::NewStub(channel_)); } std::shared_ptr<ChannelInterface> channel_; std::unique_ptr<grpc::cpp::test::util::TestService::Stub> stub_; std::unique_ptr<Server> server_; + std::unique_ptr<Server> proxy_server_; + std::unique_ptr<Proxy> proxy_service_; std::ostringstream server_address_; const int kMaxMessageSize_; TestServiceImpl service_; @@ -306,7 +344,7 @@ static void SendRpc(grpc::cpp::test::util::TestService::Stub* stub, } TEST_F(End2endTest, SimpleRpcWithHost) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; @@ -321,13 +359,13 @@ TEST_F(End2endTest, SimpleRpcWithHost) { EXPECT_TRUE(s.ok()); } -TEST_F(End2endTest, SimpleRpc) { - ResetStub(); +TEST_P(End2endTest, SimpleRpc) { + ResetStub(GetParam()); SendRpc(stub_.get(), 1); } -TEST_F(End2endTest, MultipleRpcs) { - ResetStub(); +TEST_P(End2endTest, MultipleRpcs) { + ResetStub(GetParam()); std::vector<std::thread*> threads; for (int i = 0; i < 10; ++i) { threads.push_back(new std::thread(SendRpc, stub_.get(), 10)); @@ -339,8 +377,8 @@ TEST_F(End2endTest, MultipleRpcs) { } // Set a 10us deadline and make sure proper error is returned. -TEST_F(End2endTest, RpcDeadlineExpires) { - ResetStub(); +TEST_P(End2endTest, RpcDeadlineExpires) { + ResetStub(GetParam()); EchoRequest request; EchoResponse response; request.set_message("Hello"); @@ -354,8 +392,8 @@ TEST_F(End2endTest, RpcDeadlineExpires) { } // Set a long but finite deadline. -TEST_F(End2endTest, RpcLongDeadline) { - ResetStub(); +TEST_P(End2endTest, RpcLongDeadline) { + ResetStub(GetParam()); EchoRequest request; EchoResponse response; request.set_message("Hello"); @@ -370,8 +408,8 @@ TEST_F(End2endTest, RpcLongDeadline) { } // Ask server to echo back the deadline it sees. -TEST_F(End2endTest, EchoDeadline) { - ResetStub(); +TEST_P(End2endTest, EchoDeadline) { + ResetStub(GetParam()); EchoRequest request; EchoResponse response; request.set_message("Hello"); @@ -392,8 +430,8 @@ TEST_F(End2endTest, EchoDeadline) { } // Ask server to echo back the deadline it sees. The rpc has no deadline. -TEST_F(End2endTest, EchoDeadlineForNoDeadlineRpc) { - ResetStub(); +TEST_P(End2endTest, EchoDeadlineForNoDeadlineRpc) { + ResetStub(GetParam()); EchoRequest request; EchoResponse response; request.set_message("Hello"); @@ -407,8 +445,8 @@ TEST_F(End2endTest, EchoDeadlineForNoDeadlineRpc) { gpr_inf_future(GPR_CLOCK_REALTIME).tv_sec); } -TEST_F(End2endTest, UnimplementedRpc) { - ResetStub(); +TEST_P(End2endTest, UnimplementedRpc) { + ResetStub(GetParam()); EchoRequest request; EchoResponse response; request.set_message("Hello"); @@ -422,7 +460,7 @@ TEST_F(End2endTest, UnimplementedRpc) { } TEST_F(End2endTest, RequestStreamOneRequest) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; ClientContext context; @@ -437,7 +475,7 @@ TEST_F(End2endTest, RequestStreamOneRequest) { } TEST_F(End2endTest, RequestStreamTwoRequests) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; ClientContext context; @@ -453,7 +491,7 @@ TEST_F(End2endTest, RequestStreamTwoRequests) { } TEST_F(End2endTest, ResponseStream) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; ClientContext context; @@ -473,7 +511,7 @@ TEST_F(End2endTest, ResponseStream) { } TEST_F(End2endTest, BidiStream) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; ClientContext context; @@ -506,7 +544,7 @@ TEST_F(End2endTest, BidiStream) { // Talk to the two services with the same name but different package names. // The two stubs are created on the same channel. TEST_F(End2endTest, DiffPackageServices) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; request.set_message("Hello"); @@ -561,8 +599,8 @@ void CancelRpc(ClientContext* context, int delay_us, TestServiceImpl* service) { } // Client cancels rpc after 10ms -TEST_F(End2endTest, ClientCancelsRpc) { - ResetStub(); +TEST_P(End2endTest, ClientCancelsRpc) { + ResetStub(GetParam()); EchoRequest request; EchoResponse response; request.set_message("Hello"); @@ -578,8 +616,8 @@ TEST_F(End2endTest, ClientCancelsRpc) { } // Server cancels rpc after 1ms -TEST_F(End2endTest, ServerCancelsRpc) { - ResetStub(); +TEST_P(End2endTest, ServerCancelsRpc) { + ResetStub(GetParam()); EchoRequest request; EchoResponse response; request.set_message("Hello"); @@ -593,7 +631,7 @@ TEST_F(End2endTest, ServerCancelsRpc) { // Client cancels request stream after sending two messages TEST_F(End2endTest, ClientCancelsRequestStream) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; ClientContext context; @@ -613,7 +651,7 @@ TEST_F(End2endTest, ClientCancelsRequestStream) { // Client cancels server stream after sending some messages TEST_F(End2endTest, ClientCancelsResponseStream) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; ClientContext context; @@ -645,7 +683,7 @@ TEST_F(End2endTest, ClientCancelsResponseStream) { // Client cancels bidi stream after sending some messages TEST_F(End2endTest, ClientCancelsBidi) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; ClientContext context; @@ -677,7 +715,7 @@ TEST_F(End2endTest, ClientCancelsBidi) { } TEST_F(End2endTest, RpcMaxMessageSize) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; request.set_message(string(kMaxMessageSize_ * 2, 'a')); @@ -702,7 +740,7 @@ bool MetadataContains(const std::multimap<grpc::string, grpc::string>& metadata, } TEST_F(End2endTest, SetPerCallCredentials) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; ClientContext context; @@ -724,7 +762,7 @@ TEST_F(End2endTest, SetPerCallCredentials) { } TEST_F(End2endTest, InsecurePerCallCredentials) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; ClientContext context; @@ -739,7 +777,7 @@ TEST_F(End2endTest, InsecurePerCallCredentials) { } TEST_F(End2endTest, OverridePerCallCredentials) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; ClientContext context; @@ -772,7 +810,7 @@ TEST_F(End2endTest, OverridePerCallCredentials) { // Client sends 20 requests and the server returns CANCELLED status after // reading 10 requests. TEST_F(End2endTest, RequestStreamServerEarlyCancelTest) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; ClientContext context; @@ -791,7 +829,7 @@ TEST_F(End2endTest, RequestStreamServerEarlyCancelTest) { } TEST_F(End2endTest, ClientAuthContext) { - ResetStub(); + ResetStub(false); EchoRequest request; EchoResponse response; request.set_message("Hello"); @@ -816,8 +854,8 @@ TEST_F(End2endTest, ClientAuthContext) { } // Make the response larger than the flow control window. -TEST_F(End2endTest, HugeResponse) { - ResetStub(); +TEST_P(End2endTest, HugeResponse) { + ResetStub(GetParam()); EchoRequest request; EchoResponse response; request.set_message("huge response"); @@ -842,7 +880,7 @@ void ReaderThreadFunc(ClientReaderWriter<EchoRequest, EchoResponse>* stream, gpr // Run a Read and a WritesDone simultaneously. TEST_F(End2endTest, SimultaneousReadWritesDone) { - ResetStub(); + ResetStub(false); ClientContext context; gpr_event ev; gpr_event_init(&ev); @@ -855,8 +893,8 @@ TEST_F(End2endTest, SimultaneousReadWritesDone) { reader_thread.join(); } -TEST_F(End2endTest, Peer) { - ResetStub(); +TEST_P(End2endTest, Peer) { + ResetStub(GetParam()); EchoRequest request; EchoResponse response; request.set_message("hello"); @@ -870,6 +908,8 @@ TEST_F(End2endTest, Peer) { EXPECT_TRUE(CheckIsLocalhost(context.peer())); } +INSTANTIATE_TEST_CASE_P(End2end, End2endTest, ::testing::Values(false, true)); + } // namespace testing } // namespace grpc |