Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 1 | /* |
| 2 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 3 | * Copyright 2015 gRPC authors. |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [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 |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 8 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [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. |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 16 | * |
| 17 | */ |
| 18 | |
Craig Tiller | 42bc87c | 2015-02-23 08:50:19 -0800 | [diff] [blame] | 19 | #include <grpc/grpc.h> |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 20 | |
yangg | 4105e2b | 2015-01-09 14:19:44 -0800 | [diff] [blame] | 21 | #include <string.h> |
| 22 | |
Craig Tiller | 2c8063c | 2016-03-22 22:12:15 -0700 | [diff] [blame] | 23 | #include <grpc/support/alloc.h> |
| 24 | #include <grpc/support/log.h> |
Craig Tiller | 3bf289d | 2017-03-31 14:32:51 -0700 | [diff] [blame] | 25 | |
Craig Tiller | 85db779 | 2017-04-11 10:46:31 -0700 | [diff] [blame] | 26 | #include "src/core/lib/support/atomic.h" |
| 27 | |
Craig Tiller | 9533d04 | 2016-03-25 17:11:06 -0700 | [diff] [blame] | 28 | #include "src/core/lib/channel/channel_stack.h" |
| 29 | #include "src/core/lib/support/string.h" |
| 30 | #include "src/core/lib/surface/api_trace.h" |
| 31 | #include "src/core/lib/surface/call.h" |
| 32 | #include "src/core/lib/surface/channel.h" |
Craig Tiller | 3bf289d | 2017-03-31 14:32:51 -0700 | [diff] [blame] | 33 | #include "src/core/lib/surface/lame_client.h" |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 34 | #include "src/core/lib/transport/static_metadata.h" |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 35 | |
Craig Tiller | 3bf289d | 2017-03-31 14:32:51 -0700 | [diff] [blame] | 36 | namespace grpc_core { |
| 37 | |
| 38 | namespace { |
| 39 | |
| 40 | struct CallData { |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 41 | grpc_call_combiner* call_combiner; |
Craig Tiller | bec41a2 | 2015-04-27 18:47:40 -0700 | [diff] [blame] | 42 | grpc_linked_mdelem status; |
| 43 | grpc_linked_mdelem details; |
Craig Tiller | 85db779 | 2017-04-11 10:46:31 -0700 | [diff] [blame] | 44 | grpc_core::atomic<bool> filled_metadata; |
Craig Tiller | 3bf289d | 2017-03-31 14:32:51 -0700 | [diff] [blame] | 45 | }; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 46 | |
Craig Tiller | 3bf289d | 2017-03-31 14:32:51 -0700 | [diff] [blame] | 47 | struct ChannelData { |
yang-g | c31cd86 | 2015-08-17 15:37:27 -0700 | [diff] [blame] | 48 | grpc_status_code error_code; |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 49 | const char* error_message; |
Craig Tiller | 3bf289d | 2017-03-31 14:32:51 -0700 | [diff] [blame] | 50 | }; |
yangg | 4105e2b | 2015-01-09 14:19:44 -0800 | [diff] [blame] | 51 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 52 | static void fill_metadata(grpc_exec_ctx* exec_ctx, grpc_call_element* elem, |
| 53 | grpc_metadata_batch* mdb) { |
| 54 | CallData* calld = reinterpret_cast<CallData*>(elem->call_data); |
Craig Tiller | 3bf289d | 2017-03-31 14:32:51 -0700 | [diff] [blame] | 55 | bool expected = false; |
| 56 | if (!calld->filled_metadata.compare_exchange_strong( |
Craig Tiller | 85db779 | 2017-04-11 10:46:31 -0700 | [diff] [blame] | 57 | expected, true, grpc_core::memory_order_relaxed, |
| 58 | grpc_core::memory_order_relaxed)) { |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 59 | return; |
| 60 | } |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 61 | ChannelData* chand = reinterpret_cast<ChannelData*>(elem->channel_data); |
Craig Tiller | c7e1a2a | 2015-11-02 14:17:32 -0800 | [diff] [blame] | 62 | char tmp[GPR_LTOA_MIN_BUFSIZE]; |
| 63 | gpr_ltoa(chand->error_code, tmp); |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 64 | calld->status.md = grpc_mdelem_from_slices( |
| 65 | exec_ctx, GRPC_MDSTR_GRPC_STATUS, grpc_slice_from_copied_string(tmp)); |
| 66 | calld->details.md = grpc_mdelem_from_slices( |
| 67 | exec_ctx, GRPC_MDSTR_GRPC_MESSAGE, |
| 68 | grpc_slice_from_copied_string(chand->error_message)); |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 69 | calld->status.prev = calld->details.next = nullptr; |
Craig Tiller | c7e1a2a | 2015-11-02 14:17:32 -0800 | [diff] [blame] | 70 | calld->status.next = &calld->details; |
| 71 | calld->details.prev = &calld->status; |
| 72 | mdb->list.head = &calld->status; |
| 73 | mdb->list.tail = &calld->details; |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 74 | mdb->list.count = 2; |
Craig Tiller | 89c1428 | 2017-07-19 15:32:27 -0700 | [diff] [blame] | 75 | mdb->deadline = GRPC_MILLIS_INF_FUTURE; |
Craig Tiller | c7e1a2a | 2015-11-02 14:17:32 -0800 | [diff] [blame] | 76 | } |
| 77 | |
Craig Tiller | e1b51da | 2017-03-31 15:44:33 -0700 | [diff] [blame] | 78 | static void lame_start_transport_stream_op_batch( |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 79 | grpc_exec_ctx* exec_ctx, grpc_call_element* elem, |
| 80 | grpc_transport_stream_op_batch* op) { |
| 81 | CallData* calld = reinterpret_cast<CallData*>(elem->call_data); |
Craig Tiller | 72920cc | 2017-03-10 10:20:17 -0800 | [diff] [blame] | 82 | if (op->recv_initial_metadata) { |
| 83 | fill_metadata(exec_ctx, elem, |
| 84 | op->payload->recv_initial_metadata.recv_initial_metadata); |
| 85 | } else if (op->recv_trailing_metadata) { |
| 86 | fill_metadata(exec_ctx, elem, |
| 87 | op->payload->recv_trailing_metadata.recv_trailing_metadata); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 88 | } |
Craig Tiller | a0f3abd | 2017-03-31 15:42:16 -0700 | [diff] [blame] | 89 | grpc_transport_stream_op_batch_finish_with_failure( |
Mark D. Roth | 76e264b | 2017-08-25 09:03:33 -0700 | [diff] [blame] | 90 | exec_ctx, op, GRPC_ERROR_CREATE_FROM_STATIC_STRING("lame client channel"), |
| 91 | calld->call_combiner); |
Craig Tiller | 1b22b9d | 2015-07-20 13:42:22 -0700 | [diff] [blame] | 92 | } |
| 93 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 94 | static void lame_get_channel_info(grpc_exec_ctx* exec_ctx, |
| 95 | grpc_channel_element* elem, |
| 96 | const grpc_channel_info* channel_info) {} |
Mark D. Roth | b2d2488 | 2016-10-27 15:44:07 -0700 | [diff] [blame] | 97 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 98 | static void lame_start_transport_op(grpc_exec_ctx* exec_ctx, |
| 99 | grpc_channel_element* elem, |
| 100 | grpc_transport_op* op) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 101 | if (op->on_connectivity_state_change) { |
Craig Tiller | 48ed92e | 2016-06-02 11:07:12 -0700 | [diff] [blame] | 102 | GPR_ASSERT(*op->connectivity_state != GRPC_CHANNEL_SHUTDOWN); |
| 103 | *op->connectivity_state = GRPC_CHANNEL_SHUTDOWN; |
ncteisen | 274bbbe | 2017-06-08 14:57:11 -0700 | [diff] [blame] | 104 | GRPC_CLOSURE_SCHED(exec_ctx, op->on_connectivity_state_change, |
Craig Tiller | 91031da | 2016-12-28 15:44:25 -0800 | [diff] [blame] | 105 | GRPC_ERROR_NONE); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 106 | } |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 107 | if (op->send_ping != nullptr) { |
ncteisen | 274bbbe | 2017-06-08 14:57:11 -0700 | [diff] [blame] | 108 | GRPC_CLOSURE_SCHED( |
ncteisen | 4b36a3d | 2017-03-13 19:08:06 -0700 | [diff] [blame] | 109 | exec_ctx, op->send_ping, |
| 110 | GRPC_ERROR_CREATE_FROM_STATIC_STRING("lame client channel")); |
Craig Tiller | 79310ab | 2016-04-15 15:09:48 -0700 | [diff] [blame] | 111 | } |
Craig Tiller | 1c51edc | 2016-05-07 16:18:43 -0700 | [diff] [blame] | 112 | GRPC_ERROR_UNREF(op->disconnect_with_error); |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 113 | if (op->on_consumed != nullptr) { |
ncteisen | 274bbbe | 2017-06-08 14:57:11 -0700 | [diff] [blame] | 114 | GRPC_CLOSURE_SCHED(exec_ctx, op->on_consumed, GRPC_ERROR_NONE); |
Craig Tiller | 57726ca | 2016-09-12 11:59:45 -0700 | [diff] [blame] | 115 | } |
nnoble | 0c475f0 | 2014-12-05 15:37:39 -0800 | [diff] [blame] | 116 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 117 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 118 | static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx, |
| 119 | grpc_call_element* elem, |
| 120 | const grpc_call_element_args* args) { |
| 121 | CallData* calld = reinterpret_cast<CallData*>(elem->call_data); |
Mark D. Roth | 76e264b | 2017-08-25 09:03:33 -0700 | [diff] [blame] | 122 | calld->call_combiner = args->call_combiner; |
Mark D. Roth | 0badbe8 | 2016-06-23 10:15:12 -0700 | [diff] [blame] | 123 | return GRPC_ERROR_NONE; |
| 124 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 125 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 126 | static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem, |
| 127 | const grpc_call_final_info* final_info, |
| 128 | grpc_closure* then_schedule_closure) { |
ncteisen | 274bbbe | 2017-06-08 14:57:11 -0700 | [diff] [blame] | 129 | GRPC_CLOSURE_SCHED(exec_ctx, then_schedule_closure, GRPC_ERROR_NONE); |
Craig Tiller | 2c8063c | 2016-03-22 22:12:15 -0700 | [diff] [blame] | 130 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 131 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 132 | static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx, |
| 133 | grpc_channel_element* elem, |
| 134 | grpc_channel_element_args* args) { |
Craig Tiller | c7e1a2a | 2015-11-02 14:17:32 -0800 | [diff] [blame] | 135 | GPR_ASSERT(args->is_first); |
| 136 | GPR_ASSERT(args->is_last); |
Mark D. Roth | 5e2566e | 2016-11-18 10:53:13 -0800 | [diff] [blame] | 137 | return GRPC_ERROR_NONE; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 138 | } |
| 139 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 140 | static void destroy_channel_elem(grpc_exec_ctx* exec_ctx, |
| 141 | grpc_channel_element* elem) {} |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 142 | |
Craig Tiller | 3bf289d | 2017-03-31 14:32:51 -0700 | [diff] [blame] | 143 | } // namespace |
| 144 | |
| 145 | } // namespace grpc_core |
| 146 | |
ncteisen | adbfbd5 | 2017-11-16 15:35:45 -0800 | [diff] [blame] | 147 | const grpc_channel_filter grpc_lame_filter = { |
Craig Tiller | eb36437 | 2017-04-07 17:08:42 -0700 | [diff] [blame] | 148 | grpc_core::lame_start_transport_stream_op_batch, |
Craig Tiller | 3bf289d | 2017-03-31 14:32:51 -0700 | [diff] [blame] | 149 | grpc_core::lame_start_transport_op, |
| 150 | sizeof(grpc_core::CallData), |
| 151 | grpc_core::init_call_elem, |
David Garcia Quintas | 4afce7e | 2016-04-18 16:25:17 -0700 | [diff] [blame] | 152 | grpc_call_stack_ignore_set_pollset_or_pollset_set, |
Craig Tiller | 3bf289d | 2017-03-31 14:32:51 -0700 | [diff] [blame] | 153 | grpc_core::destroy_call_elem, |
| 154 | sizeof(grpc_core::ChannelData), |
| 155 | grpc_core::init_channel_elem, |
| 156 | grpc_core::destroy_channel_elem, |
Craig Tiller | 3bf289d | 2017-03-31 14:32:51 -0700 | [diff] [blame] | 157 | grpc_core::lame_get_channel_info, |
Craig Tiller | f40df23 | 2016-03-25 13:38:14 -0700 | [diff] [blame] | 158 | "lame-client", |
Craig Tiller | 87d5b19 | 2015-04-16 14:37:57 -0700 | [diff] [blame] | 159 | }; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 160 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 161 | #define CHANNEL_STACK_FROM_CHANNEL(c) ((grpc_channel_stack*)((c) + 1)) |
yang-g | c31cd86 | 2015-08-17 15:37:27 -0700 | [diff] [blame] | 162 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 163 | grpc_channel* grpc_lame_client_channel_create(const char* target, |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 164 | grpc_status_code error_code, |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 165 | const char* error_message) { |
Craig Tiller | 178edfa | 2016-02-17 20:54:46 -0800 | [diff] [blame] | 166 | grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 167 | grpc_channel_element* elem; |
Craig Tiller | be98d24 | 2017-11-10 15:26:57 -0800 | [diff] [blame] | 168 | grpc_channel* channel = grpc_channel_create( |
| 169 | &exec_ctx, target, nullptr, GRPC_CLIENT_LAME_CHANNEL, nullptr); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 170 | elem = grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0); |
Masood Malekghassemi | 76c3d74 | 2015-08-19 18:22:53 -0700 | [diff] [blame] | 171 | GRPC_API_TRACE( |
| 172 | "grpc_lame_client_channel_create(target=%s, error_code=%d, " |
Craig Tiller | 4de3e4f | 2015-10-05 08:55:50 -0700 | [diff] [blame] | 173 | "error_message=%s)", |
Masood Malekghassemi | 76c3d74 | 2015-08-19 18:22:53 -0700 | [diff] [blame] | 174 | 3, (target, (int)error_code, error_message)); |
Craig Tiller | 178edfa | 2016-02-17 20:54:46 -0800 | [diff] [blame] | 175 | GPR_ASSERT(elem->filter == &grpc_lame_filter); |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 176 | auto chand = reinterpret_cast<grpc_core::ChannelData*>(elem->channel_data); |
yang-g | c31cd86 | 2015-08-17 15:37:27 -0700 | [diff] [blame] | 177 | chand->error_code = error_code; |
| 178 | chand->error_message = error_message; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 179 | grpc_exec_ctx_finish(&exec_ctx); |
yang-g | c31cd86 | 2015-08-17 15:37:27 -0700 | [diff] [blame] | 180 | return channel; |
Craig Tiller | 190d360 | 2015-02-18 09:23:38 -0800 | [diff] [blame] | 181 | } |