Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 1 | /* |
| 2 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 3 | * Copyright 2016 gRPC authors. |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 4 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 8 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 10 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 16 | * |
| 17 | */ |
| 18 | |
| 19 | #include "test/core/end2end/end2end_tests.h" |
| 20 | |
Mark D. Roth | 44a2f25 | 2016-07-18 14:13:31 -0700 | [diff] [blame] | 21 | #include <limits.h> |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 22 | #include <stdbool.h> |
| 23 | #include <stdio.h> |
| 24 | #include <string.h> |
| 25 | |
| 26 | #include <grpc/byte_buffer.h> |
| 27 | #include <grpc/support/alloc.h> |
| 28 | #include <grpc/support/log.h> |
| 29 | #include <grpc/support/time.h> |
| 30 | #include <grpc/support/useful.h> |
| 31 | #include "src/core/lib/channel/channel_stack_builder.h" |
| 32 | #include "src/core/lib/surface/channel_init.h" |
| 33 | #include "test/core/end2end/cq_verifier.h" |
| 34 | |
| 35 | enum { TIMEOUT = 200000 }; |
| 36 | |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 37 | static bool g_enable_server_channel_filter = false; |
| 38 | static bool g_enable_client_channel_filter = false; |
| 39 | static bool g_enable_client_subchannel_filter = false; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 40 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 41 | static void* tag(intptr_t t) { return (void*)t; } |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 42 | |
| 43 | static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 44 | const char* test_name, |
| 45 | grpc_channel_args* client_args, |
| 46 | grpc_channel_args* server_args) { |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 47 | grpc_end2end_test_fixture f; |
Robbie Shade | 55a046a | 2017-01-25 15:14:28 -0500 | [diff] [blame] | 48 | gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 49 | f = config.create_fixture(client_args, server_args); |
| 50 | config.init_server(&f, server_args); |
Mark D. Roth | e127a39 | 2016-10-27 08:27:15 -0700 | [diff] [blame] | 51 | config.init_client(&f, client_args); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 52 | return f; |
| 53 | } |
| 54 | |
Chris Evans | ed2a547 | 2017-03-27 17:34:51 -0500 | [diff] [blame] | 55 | static gpr_timespec n_seconds_from_now(int n) { |
Robbie Shade | ca7effc | 2017-01-17 09:14:29 -0500 | [diff] [blame] | 56 | return grpc_timeout_seconds_to_deadline(n); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 57 | } |
| 58 | |
Chris Evans | ed2a547 | 2017-03-27 17:34:51 -0500 | [diff] [blame] | 59 | static gpr_timespec five_seconds_from_now(void) { |
| 60 | return n_seconds_from_now(5); |
| 61 | } |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 62 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 63 | static void drain_cq(grpc_completion_queue* cq) { |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 64 | grpc_event ev; |
| 65 | do { |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 66 | ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 67 | } while (ev.type != GRPC_QUEUE_SHUTDOWN); |
| 68 | } |
| 69 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 70 | static void shutdown_server(grpc_end2end_test_fixture* f) { |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 71 | if (!f->server) return; |
Sree Kuchibhotla | 321881d | 2017-02-27 11:25:28 -0800 | [diff] [blame] | 72 | grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000)); |
| 73 | GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000), |
| 74 | grpc_timeout_seconds_to_deadline(5), |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 75 | nullptr) |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 76 | .type == GRPC_OP_COMPLETE); |
| 77 | grpc_server_destroy(f->server); |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 78 | f->server = nullptr; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 79 | } |
| 80 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 81 | static void shutdown_client(grpc_end2end_test_fixture* f) { |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 82 | if (!f->client) return; |
| 83 | grpc_channel_destroy(f->client); |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 84 | f->client = nullptr; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 85 | } |
| 86 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 87 | static void end_test(grpc_end2end_test_fixture* f) { |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 88 | shutdown_server(f); |
| 89 | shutdown_client(f); |
| 90 | |
| 91 | grpc_completion_queue_shutdown(f->cq); |
| 92 | drain_cq(f->cq); |
| 93 | grpc_completion_queue_destroy(f->cq); |
Sree Kuchibhotla | 321881d | 2017-02-27 11:25:28 -0800 | [diff] [blame] | 94 | grpc_completion_queue_destroy(f->shutdown_cq); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 95 | } |
| 96 | |
Mark D. Roth | b39bf85 | 2017-04-05 08:55:37 -0700 | [diff] [blame] | 97 | // Simple request via a SERVER_CHANNEL filter that always fails to |
Mark D. Roth | e645d13 | 2017-04-05 06:47:35 -0700 | [diff] [blame] | 98 | // initialize the call. |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 99 | static void test_server_channel_filter(grpc_end2end_test_config config) { |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 100 | grpc_call* c; |
| 101 | grpc_call* s; |
Craig Tiller | 28b7242 | 2016-10-26 21:15:29 -0700 | [diff] [blame] | 102 | grpc_slice request_payload_slice = |
| 103 | grpc_slice_from_copied_string("hello world"); |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 104 | grpc_byte_buffer* request_payload = |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 105 | grpc_raw_byte_buffer_create(&request_payload_slice, 1); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 106 | grpc_end2end_test_fixture f = |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 107 | begin_test(config, "filter_call_init_fails", nullptr, nullptr); |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 108 | cq_verifier* cqv = cq_verifier_create(f.cq); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 109 | grpc_op ops[6]; |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 110 | grpc_op* op; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 111 | grpc_metadata_array initial_metadata_recv; |
| 112 | grpc_metadata_array trailing_metadata_recv; |
| 113 | grpc_metadata_array request_metadata_recv; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 114 | grpc_byte_buffer* request_payload_recv = nullptr; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 115 | grpc_call_details call_details; |
| 116 | grpc_status_code status; |
| 117 | grpc_call_error error; |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 118 | grpc_slice details; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 119 | |
Chris Evans | ed2a547 | 2017-03-27 17:34:51 -0500 | [diff] [blame] | 120 | gpr_timespec deadline = five_seconds_from_now(); |
Muxi Yan | 5ebd327 | 2016-10-31 07:27:07 -0700 | [diff] [blame] | 121 | c = grpc_channel_create_call( |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 122 | f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq, |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 123 | grpc_slice_from_static_string("/foo"), |
| 124 | get_host_override_slice("foo.test.google.fr:1234", config), deadline, |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 125 | nullptr); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 126 | GPR_ASSERT(c); |
| 127 | |
| 128 | grpc_metadata_array_init(&initial_metadata_recv); |
| 129 | grpc_metadata_array_init(&trailing_metadata_recv); |
| 130 | grpc_metadata_array_init(&request_metadata_recv); |
| 131 | grpc_call_details_init(&call_details); |
| 132 | |
| 133 | memset(ops, 0, sizeof(ops)); |
| 134 | op = ops; |
| 135 | op->op = GRPC_OP_SEND_INITIAL_METADATA; |
| 136 | op->data.send_initial_metadata.count = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 137 | op->data.send_initial_metadata.metadata = nullptr; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 138 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 139 | op->reserved = nullptr; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 140 | op++; |
| 141 | op->op = GRPC_OP_SEND_MESSAGE; |
Mark D. Roth | 435f9f2 | 2017-01-25 12:53:54 -0800 | [diff] [blame] | 142 | op->data.send_message.send_message = request_payload; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 143 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 144 | op->reserved = nullptr; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 145 | op++; |
| 146 | op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT; |
| 147 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 148 | op->reserved = nullptr; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 149 | op++; |
| 150 | op->op = GRPC_OP_RECV_INITIAL_METADATA; |
Mark D. Roth | 435f9f2 | 2017-01-25 12:53:54 -0800 | [diff] [blame] | 151 | op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 152 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 153 | op->reserved = nullptr; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 154 | op++; |
| 155 | op->op = GRPC_OP_RECV_STATUS_ON_CLIENT; |
| 156 | op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv; |
| 157 | op->data.recv_status_on_client.status = &status; |
| 158 | op->data.recv_status_on_client.status_details = &details; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 159 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 160 | op->reserved = nullptr; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 161 | op++; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 162 | error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 163 | GPR_ASSERT(GRPC_CALL_OK == error); |
| 164 | |
| 165 | error = |
| 166 | grpc_server_request_call(f.server, &s, &call_details, |
| 167 | &request_metadata_recv, f.cq, f.cq, tag(101)); |
| 168 | GPR_ASSERT(GRPC_CALL_OK == error); |
| 169 | |
Mark D. Roth | 7f9bba8 | 2016-08-25 08:35:42 -0700 | [diff] [blame] | 170 | CQ_EXPECT_COMPLETION(cqv, tag(1), 1); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 171 | cq_verify(cqv); |
| 172 | |
| 173 | GPR_ASSERT(status == GRPC_STATUS_PERMISSION_DENIED); |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 174 | GPR_ASSERT(0 == grpc_slice_str_cmp(details, "access denied")); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 175 | |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 176 | grpc_slice_unref(details); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 177 | grpc_metadata_array_destroy(&initial_metadata_recv); |
| 178 | grpc_metadata_array_destroy(&trailing_metadata_recv); |
| 179 | grpc_metadata_array_destroy(&request_metadata_recv); |
| 180 | grpc_call_details_destroy(&call_details); |
| 181 | |
Craig Tiller | dd36b15 | 2017-03-31 08:27:28 -0700 | [diff] [blame] | 182 | grpc_call_unref(c); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 183 | |
| 184 | cq_verifier_destroy(cqv); |
| 185 | |
| 186 | grpc_byte_buffer_destroy(request_payload); |
| 187 | grpc_byte_buffer_destroy(request_payload_recv); |
| 188 | |
| 189 | end_test(&f); |
| 190 | config.tear_down_data(&f); |
| 191 | } |
| 192 | |
Mark D. Roth | b39bf85 | 2017-04-05 08:55:37 -0700 | [diff] [blame] | 193 | // Simple request via a CLIENT_CHANNEL or CLIENT_DIRECT_CHANNEL filter |
| 194 | // that always fails to initialize the call. |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 195 | static void test_client_channel_filter(grpc_end2end_test_config config) { |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 196 | grpc_call* c; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 197 | grpc_slice request_payload_slice = |
| 198 | grpc_slice_from_copied_string("hello world"); |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 199 | grpc_byte_buffer* request_payload = |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 200 | grpc_raw_byte_buffer_create(&request_payload_slice, 1); |
Mark D. Roth | e645d13 | 2017-04-05 06:47:35 -0700 | [diff] [blame] | 201 | gpr_timespec deadline = five_seconds_from_now(); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 202 | grpc_end2end_test_fixture f = |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 203 | begin_test(config, "filter_call_init_fails", nullptr, nullptr); |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 204 | cq_verifier* cqv = cq_verifier_create(f.cq); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 205 | grpc_op ops[6]; |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 206 | grpc_op* op; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 207 | grpc_metadata_array initial_metadata_recv; |
| 208 | grpc_metadata_array trailing_metadata_recv; |
| 209 | grpc_metadata_array request_metadata_recv; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 210 | grpc_byte_buffer* request_payload_recv = nullptr; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 211 | grpc_call_details call_details; |
| 212 | grpc_status_code status; |
| 213 | grpc_call_error error; |
| 214 | grpc_slice details; |
| 215 | |
| 216 | c = grpc_channel_create_call( |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 217 | f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq, |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 218 | grpc_slice_from_static_string("/foo"), |
| 219 | get_host_override_slice("foo.test.google.fr:1234", config), deadline, |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 220 | nullptr); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 221 | GPR_ASSERT(c); |
| 222 | |
| 223 | grpc_metadata_array_init(&initial_metadata_recv); |
| 224 | grpc_metadata_array_init(&trailing_metadata_recv); |
| 225 | grpc_metadata_array_init(&request_metadata_recv); |
| 226 | grpc_call_details_init(&call_details); |
| 227 | |
| 228 | memset(ops, 0, sizeof(ops)); |
| 229 | op = ops; |
| 230 | op->op = GRPC_OP_SEND_INITIAL_METADATA; |
| 231 | op->data.send_initial_metadata.count = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 232 | op->data.send_initial_metadata.metadata = nullptr; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 233 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 234 | op->reserved = nullptr; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 235 | op++; |
| 236 | op->op = GRPC_OP_SEND_MESSAGE; |
| 237 | op->data.send_message.send_message = request_payload; |
| 238 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 239 | op->reserved = nullptr; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 240 | op++; |
| 241 | op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT; |
| 242 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 243 | op->reserved = nullptr; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 244 | op++; |
| 245 | op->op = GRPC_OP_RECV_INITIAL_METADATA; |
| 246 | op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv; |
| 247 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 248 | op->reserved = nullptr; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 249 | op++; |
| 250 | op->op = GRPC_OP_RECV_STATUS_ON_CLIENT; |
| 251 | op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv; |
| 252 | op->data.recv_status_on_client.status = &status; |
| 253 | op->data.recv_status_on_client.status_details = &details; |
| 254 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 255 | op->reserved = nullptr; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 256 | op++; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 257 | error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 258 | GPR_ASSERT(GRPC_CALL_OK == error); |
| 259 | |
| 260 | CQ_EXPECT_COMPLETION(cqv, tag(1), 1); |
| 261 | cq_verify(cqv); |
| 262 | |
| 263 | GPR_ASSERT(status == GRPC_STATUS_PERMISSION_DENIED); |
| 264 | GPR_ASSERT(0 == grpc_slice_str_cmp(details, "access denied")); |
| 265 | |
| 266 | grpc_slice_unref(details); |
| 267 | grpc_metadata_array_destroy(&initial_metadata_recv); |
| 268 | grpc_metadata_array_destroy(&trailing_metadata_recv); |
| 269 | grpc_metadata_array_destroy(&request_metadata_recv); |
| 270 | grpc_call_details_destroy(&call_details); |
| 271 | |
Craig Tiller | 694cd70 | 2017-04-13 07:11:34 -0700 | [diff] [blame] | 272 | grpc_call_unref(c); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 273 | |
| 274 | cq_verifier_destroy(cqv); |
| 275 | |
| 276 | grpc_byte_buffer_destroy(request_payload); |
| 277 | grpc_byte_buffer_destroy(request_payload_recv); |
| 278 | |
| 279 | end_test(&f); |
| 280 | config.tear_down_data(&f); |
| 281 | } |
| 282 | |
Mark D. Roth | b39bf85 | 2017-04-05 08:55:37 -0700 | [diff] [blame] | 283 | // Simple request via a CLIENT_SUBCHANNEL filter that always fails to |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 284 | // initialize the call. |
| 285 | static void test_client_subchannel_filter(grpc_end2end_test_config config) { |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 286 | grpc_call* c; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 287 | grpc_slice request_payload_slice = |
| 288 | grpc_slice_from_copied_string("hello world"); |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 289 | grpc_byte_buffer* request_payload = |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 290 | grpc_raw_byte_buffer_create(&request_payload_slice, 1); |
Mark D. Roth | e645d13 | 2017-04-05 06:47:35 -0700 | [diff] [blame] | 291 | gpr_timespec deadline = five_seconds_from_now(); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 292 | grpc_end2end_test_fixture f = |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 293 | begin_test(config, "filter_call_init_fails", nullptr, nullptr); |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 294 | cq_verifier* cqv = cq_verifier_create(f.cq); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 295 | grpc_op ops[6]; |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 296 | grpc_op* op; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 297 | grpc_metadata_array initial_metadata_recv; |
| 298 | grpc_metadata_array trailing_metadata_recv; |
| 299 | grpc_metadata_array request_metadata_recv; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 300 | grpc_byte_buffer* request_payload_recv = nullptr; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 301 | grpc_call_details call_details; |
| 302 | grpc_status_code status; |
| 303 | grpc_call_error error; |
| 304 | grpc_slice details; |
| 305 | |
| 306 | c = grpc_channel_create_call( |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 307 | f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq, |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 308 | grpc_slice_from_static_string("/foo"), |
| 309 | get_host_override_slice("foo.test.google.fr:1234", config), deadline, |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 310 | nullptr); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 311 | GPR_ASSERT(c); |
| 312 | |
| 313 | grpc_metadata_array_init(&initial_metadata_recv); |
| 314 | grpc_metadata_array_init(&trailing_metadata_recv); |
| 315 | grpc_metadata_array_init(&request_metadata_recv); |
| 316 | grpc_call_details_init(&call_details); |
| 317 | |
| 318 | memset(ops, 0, sizeof(ops)); |
| 319 | op = ops; |
| 320 | op->op = GRPC_OP_SEND_INITIAL_METADATA; |
| 321 | op->data.send_initial_metadata.count = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 322 | op->data.send_initial_metadata.metadata = nullptr; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 323 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 324 | op->reserved = nullptr; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 325 | op++; |
| 326 | op->op = GRPC_OP_SEND_MESSAGE; |
| 327 | op->data.send_message.send_message = request_payload; |
| 328 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 329 | op->reserved = nullptr; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 330 | op++; |
| 331 | op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT; |
| 332 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 333 | op->reserved = nullptr; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 334 | op++; |
| 335 | op->op = GRPC_OP_RECV_INITIAL_METADATA; |
| 336 | op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv; |
| 337 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 338 | op->reserved = nullptr; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 339 | op++; |
| 340 | op->op = GRPC_OP_RECV_STATUS_ON_CLIENT; |
| 341 | op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv; |
| 342 | op->data.recv_status_on_client.status = &status; |
| 343 | op->data.recv_status_on_client.status_details = &details; |
| 344 | op->flags = 0; |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 345 | op->reserved = nullptr; |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 346 | op++; |
| 347 | |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 348 | error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 349 | GPR_ASSERT(GRPC_CALL_OK == error); |
| 350 | |
| 351 | CQ_EXPECT_COMPLETION(cqv, tag(1), 1); |
| 352 | cq_verify(cqv); |
| 353 | |
| 354 | GPR_ASSERT(status == GRPC_STATUS_PERMISSION_DENIED); |
| 355 | GPR_ASSERT(0 == grpc_slice_str_cmp(details, "access denied")); |
| 356 | |
| 357 | // Reset and create a new call. (The first call uses a different code |
| 358 | // path in client_channel.c than subsequent calls on the same channel, |
| 359 | // and we need to test both.) |
Craig Tiller | 694cd70 | 2017-04-13 07:11:34 -0700 | [diff] [blame] | 360 | grpc_call_unref(c); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 361 | status = GRPC_STATUS_OK; |
| 362 | grpc_slice_unref(details); |
| 363 | details = grpc_empty_slice(); |
| 364 | |
| 365 | c = grpc_channel_create_call( |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 366 | f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq, |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 367 | grpc_slice_from_static_string("/foo"), |
| 368 | get_host_override_slice("foo.test.google.fr:1234", config), deadline, |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 369 | nullptr); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 370 | GPR_ASSERT(c); |
| 371 | |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 372 | error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 373 | GPR_ASSERT(GRPC_CALL_OK == error); |
| 374 | |
| 375 | CQ_EXPECT_COMPLETION(cqv, tag(2), 1); |
| 376 | cq_verify(cqv); |
| 377 | |
| 378 | GPR_ASSERT(status == GRPC_STATUS_PERMISSION_DENIED); |
| 379 | GPR_ASSERT(0 == grpc_slice_str_cmp(details, "access denied")); |
| 380 | |
| 381 | grpc_slice_unref(details); |
| 382 | grpc_metadata_array_destroy(&initial_metadata_recv); |
| 383 | grpc_metadata_array_destroy(&trailing_metadata_recv); |
| 384 | grpc_metadata_array_destroy(&request_metadata_recv); |
| 385 | grpc_call_details_destroy(&call_details); |
| 386 | |
Craig Tiller | 694cd70 | 2017-04-13 07:11:34 -0700 | [diff] [blame] | 387 | grpc_call_unref(c); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 388 | |
| 389 | cq_verifier_destroy(cqv); |
| 390 | |
| 391 | grpc_byte_buffer_destroy(request_payload); |
| 392 | grpc_byte_buffer_destroy(request_payload_recv); |
| 393 | |
| 394 | end_test(&f); |
| 395 | config.tear_down_data(&f); |
| 396 | } |
| 397 | |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 398 | /******************************************************************************* |
| 399 | * Test filter - always fails to initialize a call |
| 400 | */ |
| 401 | |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 402 | static grpc_error* init_call_elem(grpc_call_element* elem, |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 403 | const grpc_call_element_args* args) { |
ncteisen | 4b36a3d | 2017-03-13 19:08:06 -0700 | [diff] [blame] | 404 | return grpc_error_set_int( |
| 405 | GRPC_ERROR_CREATE_FROM_STATIC_STRING("access denied"), |
| 406 | GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_PERMISSION_DENIED); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 407 | } |
| 408 | |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 409 | static void destroy_call_elem(grpc_call_element* elem, |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 410 | const grpc_call_final_info* final_info, |
| 411 | grpc_closure* ignored) {} |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 412 | |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 413 | static grpc_error* init_channel_elem(grpc_channel_element* elem, |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 414 | grpc_channel_element_args* args) { |
Mark D. Roth | 5e2566e | 2016-11-18 10:53:13 -0800 | [diff] [blame] | 415 | return GRPC_ERROR_NONE; |
| 416 | } |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 417 | |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 418 | static void destroy_channel_elem(grpc_channel_element* elem) {} |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 419 | |
| 420 | static const grpc_channel_filter test_filter = { |
| 421 | grpc_call_next_op, |
| 422 | grpc_channel_next_op, |
| 423 | 0, |
| 424 | init_call_elem, |
| 425 | grpc_call_stack_ignore_set_pollset_or_pollset_set, |
| 426 | destroy_call_elem, |
| 427 | 0, |
| 428 | init_channel_elem, |
| 429 | destroy_channel_elem, |
Mark D. Roth | b2d2488 | 2016-10-27 15:44:07 -0700 | [diff] [blame] | 430 | grpc_channel_next_get_info, |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 431 | "filter_call_init_fails"}; |
| 432 | |
| 433 | /******************************************************************************* |
| 434 | * Registration |
| 435 | */ |
| 436 | |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 437 | static bool maybe_add_server_channel_filter(grpc_channel_stack_builder* builder, |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 438 | void* arg) { |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 439 | if (g_enable_server_channel_filter) { |
Mark D. Roth | b5f32f0 | 2016-07-19 08:36:52 -0700 | [diff] [blame] | 440 | // Want to add the filter as close to the end as possible, to make |
| 441 | // sure that all of the filters work well together. However, we |
| 442 | // can't add it at the very end, because the connected channel filter |
| 443 | // must be the last one. So we add it right before the last one. |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 444 | grpc_channel_stack_builder_iterator* it = |
Mark D. Roth | b5f32f0 | 2016-07-19 08:36:52 -0700 | [diff] [blame] | 445 | grpc_channel_stack_builder_create_iterator_at_last(builder); |
| 446 | GPR_ASSERT(grpc_channel_stack_builder_move_prev(it)); |
Mark D. Roth | 05d73af | 2016-07-27 15:52:46 +0000 | [diff] [blame] | 447 | const bool retval = grpc_channel_stack_builder_add_filter_before( |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 448 | it, &test_filter, nullptr, nullptr); |
Mark D. Roth | 05d73af | 2016-07-27 15:52:46 +0000 | [diff] [blame] | 449 | grpc_channel_stack_builder_iterator_destroy(it); |
| 450 | return retval; |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 451 | } else { |
| 452 | return true; |
| 453 | } |
| 454 | } |
| 455 | |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 456 | static bool maybe_add_client_channel_filter(grpc_channel_stack_builder* builder, |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 457 | void* arg) { |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 458 | if (g_enable_client_channel_filter) { |
| 459 | // Want to add the filter as close to the end as possible, to make |
| 460 | // sure that all of the filters work well together. However, we |
| 461 | // can't add it at the very end, because the connected channel filter |
| 462 | // must be the last one. So we add it right before the last one. |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 463 | grpc_channel_stack_builder_iterator* it = |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 464 | grpc_channel_stack_builder_create_iterator_at_last(builder); |
| 465 | GPR_ASSERT(grpc_channel_stack_builder_move_prev(it)); |
| 466 | const bool retval = grpc_channel_stack_builder_add_filter_before( |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 467 | it, &test_filter, nullptr, nullptr); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 468 | grpc_channel_stack_builder_iterator_destroy(it); |
| 469 | return retval; |
| 470 | } else { |
| 471 | return true; |
| 472 | } |
| 473 | } |
| 474 | |
| 475 | static bool maybe_add_client_subchannel_filter( |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 476 | grpc_channel_stack_builder* builder, void* arg) { |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 477 | if (g_enable_client_subchannel_filter) { |
| 478 | // Want to add the filter as close to the end as possible, to make |
| 479 | // sure that all of the filters work well together. However, we |
| 480 | // can't add it at the very end, because the client channel filter |
| 481 | // must be the last one. So we add it right before the last one. |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 482 | grpc_channel_stack_builder_iterator* it = |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 483 | grpc_channel_stack_builder_create_iterator_at_last(builder); |
| 484 | GPR_ASSERT(grpc_channel_stack_builder_move_prev(it)); |
| 485 | const bool retval = grpc_channel_stack_builder_add_filter_before( |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 486 | it, &test_filter, nullptr, nullptr); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 487 | grpc_channel_stack_builder_iterator_destroy(it); |
| 488 | return retval; |
| 489 | } else { |
| 490 | return true; |
| 491 | } |
| 492 | } |
| 493 | |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 494 | static void init_plugin(void) { |
Mark D. Roth | 44a2f25 | 2016-07-18 14:13:31 -0700 | [diff] [blame] | 495 | grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL, INT_MAX, |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 496 | maybe_add_server_channel_filter, nullptr); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 497 | grpc_channel_init_register_stage(GRPC_CLIENT_CHANNEL, INT_MAX, |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 498 | maybe_add_client_channel_filter, nullptr); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 499 | grpc_channel_init_register_stage(GRPC_CLIENT_SUBCHANNEL, INT_MAX, |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 500 | maybe_add_client_subchannel_filter, nullptr); |
Mark D. Roth | b39bf85 | 2017-04-05 08:55:37 -0700 | [diff] [blame] | 501 | grpc_channel_init_register_stage(GRPC_CLIENT_DIRECT_CHANNEL, INT_MAX, |
Craig Tiller | 4ac2b8e | 2017-11-10 14:14:17 -0800 | [diff] [blame] | 502 | maybe_add_client_channel_filter, nullptr); |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 503 | } |
| 504 | |
| 505 | static void destroy_plugin(void) {} |
| 506 | |
| 507 | void filter_call_init_fails(grpc_end2end_test_config config) { |
Mark D. Roth | b39bf85 | 2017-04-05 08:55:37 -0700 | [diff] [blame] | 508 | gpr_log(GPR_INFO, "Testing SERVER_CHANNEL filter."); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 509 | g_enable_server_channel_filter = true; |
| 510 | test_server_channel_filter(config); |
| 511 | g_enable_server_channel_filter = false; |
Mark D. Roth | b39bf85 | 2017-04-05 08:55:37 -0700 | [diff] [blame] | 512 | gpr_log(GPR_INFO, "Testing CLIENT_CHANNEL / CLIENT_DIRECT_CHANNEL filter."); |
Mark D. Roth | b7d833b | 2017-04-04 14:16:09 -0700 | [diff] [blame] | 513 | g_enable_client_channel_filter = true; |
| 514 | test_client_channel_filter(config); |
| 515 | g_enable_client_channel_filter = false; |
Mark D. Roth | b39bf85 | 2017-04-05 08:55:37 -0700 | [diff] [blame] | 516 | if (config.feature_mask & FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL) { |
| 517 | gpr_log(GPR_INFO, "Testing CLIENT_SUBCHANNEL filter."); |
| 518 | g_enable_client_subchannel_filter = true; |
| 519 | test_client_subchannel_filter(config); |
| 520 | g_enable_client_subchannel_filter = false; |
| 521 | } |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 522 | } |
| 523 | |
| 524 | void filter_call_init_fails_pre_init(void) { |
| 525 | grpc_register_plugin(init_plugin, destroy_plugin); |
| 526 | } |