Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 1 | /* |
| 2 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 3 | * Copyright 2015 gRPC authors. |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -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 |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -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 |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -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. |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 16 | * |
| 17 | */ |
| 18 | |
Craig Tiller | 9533d04 | 2016-03-25 17:11:06 -0700 | [diff] [blame] | 19 | #include "src/core/lib/surface/channel.h" |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 20 | |
Yash Tibrewal | fcd26bc | 2017-09-25 15:08:28 -0700 | [diff] [blame] | 21 | #include <inttypes.h> |
| 22 | |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 23 | #include <grpc/support/alloc.h> |
| 24 | #include <grpc/support/log.h> |
| 25 | |
Craig Tiller | 9eb0fde | 2017-03-31 16:59:30 -0700 | [diff] [blame] | 26 | #include "src/core/ext/filters/client_channel/client_channel.h" |
Craig Tiller | 9533d04 | 2016-03-25 17:11:06 -0700 | [diff] [blame] | 27 | #include "src/core/lib/iomgr/timer.h" |
| 28 | #include "src/core/lib/surface/api_trace.h" |
| 29 | #include "src/core/lib/surface/completion_queue.h" |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 30 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 31 | grpc_connectivity_state grpc_channel_check_connectivity_state( |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 32 | grpc_channel* channel, int try_to_connect) { |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 33 | /* forward through to the underlying client channel */ |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 34 | grpc_channel_element* client_channel_elem = |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 35 | grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel)); |
Craig Tiller | f5768a6 | 2015-09-22 10:54:34 -0700 | [diff] [blame] | 36 | grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
Craig Tiller | 000cd8f | 2015-09-18 07:20:29 -0700 | [diff] [blame] | 37 | grpc_connectivity_state state; |
Masood Malekghassemi | 76c3d74 | 2015-08-19 18:22:53 -0700 | [diff] [blame] | 38 | GRPC_API_TRACE( |
Craig Tiller | 4de3e4f | 2015-10-05 08:55:50 -0700 | [diff] [blame] | 39 | "grpc_channel_check_connectivity_state(channel=%p, try_to_connect=%d)", 2, |
| 40 | (channel, try_to_connect)); |
David Garcia Quintas | 7b1bd2c | 2015-10-05 18:22:10 -0700 | [diff] [blame] | 41 | if (client_channel_elem->filter == &grpc_client_channel_filter) { |
| 42 | state = grpc_client_channel_check_connectivity_state( |
| 43 | &exec_ctx, client_channel_elem, try_to_connect); |
Craig Tiller | 6301038 | 2015-09-24 15:00:58 -0700 | [diff] [blame] | 44 | grpc_exec_ctx_finish(&exec_ctx); |
David Garcia Quintas | 7b1bd2c | 2015-10-05 18:22:10 -0700 | [diff] [blame] | 45 | return state; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 46 | } |
David Garcia Quintas | 7b1bd2c | 2015-10-05 18:22:10 -0700 | [diff] [blame] | 47 | gpr_log(GPR_ERROR, |
| 48 | "grpc_channel_check_connectivity_state called on something that is " |
Nicolas "Pixel" Noble | 20b8333 | 2016-07-21 19:28:38 +0200 | [diff] [blame] | 49 | "not a client channel, but '%s'", |
| 50 | client_channel_elem->filter->name); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 51 | grpc_exec_ctx_finish(&exec_ctx); |
Craig Tiller | 48ed92e | 2016-06-02 11:07:12 -0700 | [diff] [blame] | 52 | return GRPC_CHANNEL_SHUTDOWN; |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 53 | } |
| 54 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 55 | typedef enum { |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 56 | WAITING, |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 57 | READY_TO_CALL_BACK, |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 58 | CALLING_BACK_AND_FINISHED, |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 59 | } callback_phase; |
| 60 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 61 | typedef struct { |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 62 | gpr_mu mu; |
| 63 | callback_phase phase; |
Craig Tiller | 3382511 | 2015-09-18 07:44:19 -0700 | [diff] [blame] | 64 | grpc_closure on_complete; |
Masood Malekghassemi | b5b4372 | 2017-01-05 15:07:26 -0800 | [diff] [blame] | 65 | grpc_closure on_timeout; |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 66 | grpc_closure watcher_timer_init; |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 67 | grpc_timer alarm; |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 68 | grpc_connectivity_state state; |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 69 | grpc_completion_queue* cq; |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 70 | grpc_cq_completion completion_storage; |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 71 | grpc_channel* channel; |
| 72 | grpc_error* error; |
| 73 | void* tag; |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 74 | } state_watcher; |
| 75 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 76 | static void delete_state_watcher(grpc_exec_ctx* exec_ctx, state_watcher* w) { |
| 77 | grpc_channel_element* client_channel_elem = grpc_channel_stack_last_element( |
David Garcia Quintas | 7b1bd2c | 2015-10-05 18:22:10 -0700 | [diff] [blame] | 78 | grpc_channel_get_channel_stack(w->channel)); |
| 79 | if (client_channel_elem->filter == &grpc_client_channel_filter) { |
| 80 | GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, w->channel, |
| 81 | "watch_channel_connectivity"); |
David Garcia Quintas | 7b1bd2c | 2015-10-05 18:22:10 -0700 | [diff] [blame] | 82 | } else { |
| 83 | abort(); |
| 84 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 85 | gpr_mu_destroy(&w->mu); |
| 86 | gpr_free(w); |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 87 | } |
| 88 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 89 | static void finished_completion(grpc_exec_ctx* exec_ctx, void* pw, |
| 90 | grpc_cq_completion* ignored) { |
Yash Tibrewal | bc130da | 2017-09-12 22:44:08 -0700 | [diff] [blame] | 91 | bool should_delete = false; |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 92 | state_watcher* w = (state_watcher*)pw; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 93 | gpr_mu_lock(&w->mu); |
| 94 | switch (w->phase) { |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 95 | case WAITING: |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 96 | case READY_TO_CALL_BACK: |
yang-g | b063c87 | 2015-10-07 11:40:13 -0700 | [diff] [blame] | 97 | GPR_UNREACHABLE_CODE(return ); |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 98 | case CALLING_BACK_AND_FINISHED: |
Yash Tibrewal | bc130da | 2017-09-12 22:44:08 -0700 | [diff] [blame] | 99 | should_delete = true; |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 100 | break; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 101 | } |
| 102 | gpr_mu_unlock(&w->mu); |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 103 | |
Yash Tibrewal | bc130da | 2017-09-12 22:44:08 -0700 | [diff] [blame] | 104 | if (should_delete) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 105 | delete_state_watcher(exec_ctx, w); |
| 106 | } |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 107 | } |
| 108 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 109 | static void partly_done(grpc_exec_ctx* exec_ctx, state_watcher* w, |
| 110 | bool due_to_completion, grpc_error* error) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 111 | if (due_to_completion) { |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 112 | grpc_timer_cancel(exec_ctx, &w->alarm); |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 113 | } else { |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 114 | grpc_channel_element* client_channel_elem = grpc_channel_stack_last_element( |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 115 | grpc_channel_get_channel_stack(w->channel)); |
David Garcia Quintas | 87d5a31 | 2017-06-06 19:45:58 -0700 | [diff] [blame] | 116 | grpc_client_channel_watch_connectivity_state( |
| 117 | exec_ctx, client_channel_elem, |
Craig Tiller | be98d24 | 2017-11-10 15:26:57 -0800 | [diff] [blame] | 118 | grpc_polling_entity_create_from_pollset(grpc_cq_pollset(w->cq)), |
| 119 | nullptr, &w->on_complete, nullptr); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 120 | } |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 121 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 122 | gpr_mu_lock(&w->mu); |
Craig Tiller | cfc8ae1 | 2016-05-10 20:49:54 -0700 | [diff] [blame] | 123 | |
Craig Tiller | 7b43561 | 2015-11-24 08:15:05 -0800 | [diff] [blame] | 124 | if (due_to_completion) { |
Craig Tiller | 84f75d4 | 2017-05-03 13:06:35 -0700 | [diff] [blame] | 125 | if (GRPC_TRACER_ON(grpc_trace_operation_failures)) { |
Craig Tiller | 89af61e | 2016-06-13 15:29:40 -0700 | [diff] [blame] | 126 | GRPC_LOG_IF_ERROR("watch_completion_error", GRPC_ERROR_REF(error)); |
| 127 | } |
| 128 | GRPC_ERROR_UNREF(error); |
| 129 | error = GRPC_ERROR_NONE; |
| 130 | } else { |
| 131 | if (error == GRPC_ERROR_NONE) { |
ncteisen | 4b36a3d | 2017-03-13 19:08:06 -0700 | [diff] [blame] | 132 | error = GRPC_ERROR_CREATE_FROM_STATIC_STRING( |
| 133 | "Timed out waiting for connection state change"); |
Craig Tiller | 89af61e | 2016-06-13 15:29:40 -0700 | [diff] [blame] | 134 | } else if (error == GRPC_ERROR_CANCELLED) { |
| 135 | error = GRPC_ERROR_NONE; |
| 136 | } |
Craig Tiller | 7b43561 | 2015-11-24 08:15:05 -0800 | [diff] [blame] | 137 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 138 | switch (w->phase) { |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 139 | case WAITING: |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 140 | GRPC_ERROR_REF(error); |
| 141 | w->error = error; |
| 142 | w->phase = READY_TO_CALL_BACK; |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 143 | break; |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 144 | case READY_TO_CALL_BACK: |
| 145 | if (error != GRPC_ERROR_NONE) { |
| 146 | GPR_ASSERT(!due_to_completion); |
| 147 | GRPC_ERROR_UNREF(w->error); |
| 148 | GRPC_ERROR_REF(error); |
| 149 | w->error = error; |
| 150 | } |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 151 | w->phase = CALLING_BACK_AND_FINISHED; |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 152 | grpc_cq_end_op(exec_ctx, w->cq, w->tag, w->error, finished_completion, w, |
| 153 | &w->completion_storage); |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 154 | break; |
| 155 | case CALLING_BACK_AND_FINISHED: |
yang-g | b063c87 | 2015-10-07 11:40:13 -0700 | [diff] [blame] | 156 | GPR_UNREACHABLE_CODE(return ); |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 157 | break; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 158 | } |
| 159 | gpr_mu_unlock(&w->mu); |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 160 | |
Craig Tiller | cfc8ae1 | 2016-05-10 20:49:54 -0700 | [diff] [blame] | 161 | GRPC_ERROR_UNREF(error); |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 162 | } |
| 163 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 164 | static void watch_complete(grpc_exec_ctx* exec_ctx, void* pw, |
| 165 | grpc_error* error) { |
| 166 | partly_done(exec_ctx, (state_watcher*)pw, true, GRPC_ERROR_REF(error)); |
Craig Tiller | dfff1b8 | 2015-09-21 14:39:57 -0700 | [diff] [blame] | 167 | } |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 168 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 169 | static void timeout_complete(grpc_exec_ctx* exec_ctx, void* pw, |
| 170 | grpc_error* error) { |
| 171 | partly_done(exec_ctx, (state_watcher*)pw, false, GRPC_ERROR_REF(error)); |
Craig Tiller | dfff1b8 | 2015-09-21 14:39:57 -0700 | [diff] [blame] | 172 | } |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 173 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 174 | int grpc_channel_num_external_connectivity_watchers(grpc_channel* channel) { |
| 175 | grpc_channel_element* client_channel_elem = |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 176 | grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel)); |
| 177 | return grpc_client_channel_num_external_connectivity_watchers( |
| 178 | client_channel_elem); |
| 179 | } |
| 180 | |
| 181 | typedef struct watcher_timer_init_arg { |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 182 | state_watcher* w; |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 183 | gpr_timespec deadline; |
| 184 | } watcher_timer_init_arg; |
| 185 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 186 | static void watcher_timer_init(grpc_exec_ctx* exec_ctx, void* arg, |
| 187 | grpc_error* error_ignored) { |
| 188 | watcher_timer_init_arg* wa = (watcher_timer_init_arg*)arg; |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 189 | |
| 190 | grpc_timer_init(exec_ctx, &wa->w->alarm, |
Craig Tiller | 9a8c3f3 | 2017-07-21 13:14:14 -0700 | [diff] [blame] | 191 | grpc_timespec_to_millis_round_up(wa->deadline), |
| 192 | &wa->w->on_timeout); |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 193 | gpr_free(wa); |
| 194 | } |
| 195 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 196 | int grpc_channel_support_connectivity_watcher(grpc_channel* channel) { |
| 197 | grpc_channel_element* client_channel_elem = |
Yuchen Zeng | 6a6d618 | 2017-08-22 13:43:38 -0700 | [diff] [blame] | 198 | grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel)); |
| 199 | return client_channel_elem->filter != &grpc_client_channel_filter ? 0 : 1; |
| 200 | } |
| 201 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 202 | void grpc_channel_watch_connectivity_state( |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 203 | grpc_channel* channel, grpc_connectivity_state last_observed_state, |
| 204 | gpr_timespec deadline, grpc_completion_queue* cq, void* tag) { |
| 205 | grpc_channel_element* client_channel_elem = |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 206 | grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel)); |
Craig Tiller | f5768a6 | 2015-09-22 10:54:34 -0700 | [diff] [blame] | 207 | grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 208 | state_watcher* w = (state_watcher*)gpr_malloc(sizeof(*w)); |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 209 | |
Masood Malekghassemi | 76c3d74 | 2015-08-19 18:22:53 -0700 | [diff] [blame] | 210 | GRPC_API_TRACE( |
| 211 | "grpc_channel_watch_connectivity_state(" |
Craig Tiller | 4de3e4f | 2015-10-05 08:55:50 -0700 | [diff] [blame] | 212 | "channel=%p, last_observed_state=%d, " |
Ken Payson | 62a6c92 | 2016-06-24 11:53:54 -0700 | [diff] [blame] | 213 | "deadline=gpr_timespec { tv_sec: %" PRId64 |
| 214 | ", tv_nsec: %d, clock_type: %d }, " |
Craig Tiller | 4de3e4f | 2015-10-05 08:55:50 -0700 | [diff] [blame] | 215 | "cq=%p, tag=%p)", |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 216 | 7, |
| 217 | (channel, (int)last_observed_state, deadline.tv_sec, deadline.tv_nsec, |
| 218 | (int)deadline.clock_type, cq, tag)); |
Masood Malekghassemi | 76c3d74 | 2015-08-19 18:22:53 -0700 | [diff] [blame] | 219 | |
yang-g | 7d6b914 | 2017-07-13 11:48:56 -0700 | [diff] [blame] | 220 | GPR_ASSERT(grpc_cq_begin_op(cq, tag)); |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 221 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 222 | gpr_mu_init(&w->mu); |
ncteisen | 274bbbe | 2017-06-08 14:57:11 -0700 | [diff] [blame] | 223 | GRPC_CLOSURE_INIT(&w->on_complete, watch_complete, w, |
Craig Tiller | d465456 | 2017-01-03 08:45:56 -0800 | [diff] [blame] | 224 | grpc_schedule_on_exec_ctx); |
ncteisen | 274bbbe | 2017-06-08 14:57:11 -0700 | [diff] [blame] | 225 | GRPC_CLOSURE_INIT(&w->on_timeout, timeout_complete, w, |
Masood Malekghassemi | b5b4372 | 2017-01-05 15:07:26 -0800 | [diff] [blame] | 226 | grpc_schedule_on_exec_ctx); |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 227 | w->phase = WAITING; |
| 228 | w->state = last_observed_state; |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 229 | w->cq = cq; |
| 230 | w->tag = tag; |
Craig Tiller | 1ada6ad | 2015-07-16 16:19:14 -0700 | [diff] [blame] | 231 | w->channel = channel; |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 232 | w->error = nullptr; |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 233 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 234 | watcher_timer_init_arg* wa = |
| 235 | (watcher_timer_init_arg*)gpr_malloc(sizeof(watcher_timer_init_arg)); |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 236 | wa->w = w; |
| 237 | wa->deadline = deadline; |
ncteisen | 274bbbe | 2017-06-08 14:57:11 -0700 | [diff] [blame] | 238 | GRPC_CLOSURE_INIT(&w->watcher_timer_init, watcher_timer_init, wa, |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 239 | grpc_schedule_on_exec_ctx); |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 240 | |
David Garcia Quintas | 7b1bd2c | 2015-10-05 18:22:10 -0700 | [diff] [blame] | 241 | if (client_channel_elem->filter == &grpc_client_channel_filter) { |
| 242 | GRPC_CHANNEL_INTERNAL_REF(channel, "watch_channel_connectivity"); |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 243 | grpc_client_channel_watch_connectivity_state( |
David Garcia Quintas | 87d5a31 | 2017-06-06 19:45:58 -0700 | [diff] [blame] | 244 | &exec_ctx, client_channel_elem, |
| 245 | grpc_polling_entity_create_from_pollset(grpc_cq_pollset(cq)), &w->state, |
Alexander Polcyn | c3b1f18 | 2017-04-18 13:51:36 -0700 | [diff] [blame] | 246 | &w->on_complete, &w->watcher_timer_init); |
David Garcia Quintas | fb349b9 | 2016-03-21 15:37:20 -0700 | [diff] [blame] | 247 | } else { |
| 248 | abort(); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 249 | } |
Craig Tiller | 000cd8f | 2015-09-18 07:20:29 -0700 | [diff] [blame] | 250 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 251 | grpc_exec_ctx_finish(&exec_ctx); |
Craig Tiller | 48cb07c | 2015-07-15 16:16:15 -0700 | [diff] [blame] | 252 | } |