1 /*
2 *
3 * Copyright 2015 gRPC authors.
4 *
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
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
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.
16 *
17 */
18
19 #ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_SUBCHANNEL_LIST_H
20 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_SUBCHANNEL_LIST_H
21
22 #include <grpc/support/port_platform.h>
23
24 #include <string.h>
25
26 #include <grpc/support/alloc.h>
27
28 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
29 #include "src/core/ext/filters/client_channel/server_address.h"
30 // TODO(roth): Should not need the include of subchannel.h here, since
31 // that implementation should be hidden from the LB policy API.
32 #include "src/core/ext/filters/client_channel/subchannel.h"
33 #include "src/core/ext/filters/client_channel/subchannel_interface.h"
34 #include "src/core/lib/channel/channel_args.h"
35 #include "src/core/lib/debug/trace.h"
36 #include "src/core/lib/gprpp/abstract.h"
37 #include "src/core/lib/gprpp/inlined_vector.h"
38 #include "src/core/lib/gprpp/orphanable.h"
39 #include "src/core/lib/gprpp/ref_counted.h"
40 #include "src/core/lib/gprpp/ref_counted_ptr.h"
41 #include "src/core/lib/iomgr/closure.h"
42 #include "src/core/lib/iomgr/combiner.h"
43 #include "src/core/lib/iomgr/sockaddr_utils.h"
44 #include "src/core/lib/transport/connectivity_state.h"
45
46 // Code for maintaining a list of subchannels within an LB policy.
47 //
48 // To use this, callers must create their own subclasses, like so:
49 /*
50
51 class MySubchannelList; // Forward declaration.
52
53 class MySubchannelData
54 : public SubchannelData<MySubchannelList, MySubchannelData> {
55 public:
56 void ProcessConnectivityChangeLocked(
57 grpc_connectivity_state connectivity_state) override {
58 // ...code to handle connectivity changes...
59 }
60 };
61
62 class MySubchannelList
63 : public SubchannelList<MySubchannelList, MySubchannelData> {
64 };
65
66 */
67 // All methods with a Locked() suffix must be called from within the
68 // client_channel combiner.
69
70 namespace grpc_core {
71
72 // Forward declaration.
73 template <typename SubchannelListType, typename SubchannelDataType>
74 class SubchannelList;
75
76 // Stores data for a particular subchannel in a subchannel list.
77 // Callers must create a subclass that implements the
78 // ProcessConnectivityChangeLocked() method.
79 template <typename SubchannelListType, typename SubchannelDataType>
80 class SubchannelData {
81 public:
82 // Returns a pointer to the subchannel list containing this object.
subchannel_list()83 SubchannelListType* subchannel_list() const {
84 return static_cast<SubchannelListType*>(subchannel_list_);
85 }
86
87 // Returns the index into the subchannel list of this object.
Index()88 size_t Index() const {
89 return static_cast<size_t>(static_cast<const SubchannelDataType*>(this) -
90 subchannel_list_->subchannel(0));
91 }
92
93 // Returns a pointer to the subchannel.
subchannel()94 SubchannelInterface* subchannel() const { return subchannel_.get(); }
95
96 // Returns the connected subchannel. Will be null if the subchannel
97 // is not connected.
connected_subchannel()98 ConnectedSubchannelInterface* connected_subchannel() const {
99 return connected_subchannel_.get();
100 }
101
102 // Synchronously checks the subchannel's connectivity state.
103 // Must not be called while there is a connectivity notification
104 // pending (i.e., between calling StartConnectivityWatchLocked() and
105 // calling CancelConnectivityWatchLocked()).
CheckConnectivityStateLocked()106 grpc_connectivity_state CheckConnectivityStateLocked() {
107 GPR_ASSERT(pending_watcher_ == nullptr);
108 connectivity_state_ =
109 subchannel()->CheckConnectivityState(&connected_subchannel_);
110 return connectivity_state_;
111 }
112
113 // Resets the connection backoff.
114 // TODO(roth): This method should go away when we move the backoff
115 // code out of the subchannel and into the LB policies.
116 void ResetBackoffLocked();
117
118 // Starts watching the connectivity state of the subchannel.
119 // ProcessConnectivityChangeLocked() will be called whenever the
120 // connectivity state changes.
121 void StartConnectivityWatchLocked();
122
123 // Cancels watching the connectivity state of the subchannel.
124 void CancelConnectivityWatchLocked(const char* reason);
125
126 // Cancels any pending connectivity watch and unrefs the subchannel.
127 void ShutdownLocked();
128
129 GRPC_ABSTRACT_BASE_CLASS
130
131 protected:
132 SubchannelData(
133 SubchannelList<SubchannelListType, SubchannelDataType>* subchannel_list,
134 const ServerAddress& address,
135 RefCountedPtr<SubchannelInterface> subchannel);
136
137 virtual ~SubchannelData();
138
139 // After StartConnectivityWatchLocked() is called, this method will be
140 // invoked whenever the subchannel's connectivity state changes.
141 // To stop watching, use CancelConnectivityWatchLocked().
142 virtual void ProcessConnectivityChangeLocked(
143 grpc_connectivity_state connectivity_state) GRPC_ABSTRACT;
144
145 private:
146 // Watcher for subchannel connectivity state.
147 class Watcher : public SubchannelInterface::ConnectivityStateWatcher {
148 public:
Watcher(SubchannelData<SubchannelListType,SubchannelDataType> * subchannel_data,RefCountedPtr<SubchannelListType> subchannel_list)149 Watcher(
150 SubchannelData<SubchannelListType, SubchannelDataType>* subchannel_data,
151 RefCountedPtr<SubchannelListType> subchannel_list)
152 : subchannel_data_(subchannel_data),
153 subchannel_list_(std::move(subchannel_list)) {}
154
~Watcher()155 ~Watcher() { subchannel_list_.reset(DEBUG_LOCATION, "Watcher dtor"); }
156
157 void OnConnectivityStateChange(grpc_connectivity_state new_state,
158 RefCountedPtr<ConnectedSubchannelInterface>
159 connected_subchannel) override;
160
interested_parties()161 grpc_pollset_set* interested_parties() override {
162 return subchannel_list_->policy()->interested_parties();
163 }
164
165 private:
166 // A fire-and-forget class that bounces into the combiner to process
167 // a connectivity state update.
168 class Updater {
169 public:
170 Updater(
171 SubchannelData<SubchannelListType, SubchannelDataType>*
172 subchannel_data,
173 RefCountedPtr<SubchannelList<SubchannelListType, SubchannelDataType>>
174 subchannel_list,
175 grpc_connectivity_state state,
176 RefCountedPtr<ConnectedSubchannelInterface> connected_subchannel);
177
~Updater()178 ~Updater() {
179 subchannel_list_.reset(DEBUG_LOCATION, "Watcher::Updater dtor");
180 }
181
182 private:
183 static void OnUpdateLocked(void* arg, grpc_error* error);
184
185 SubchannelData<SubchannelListType, SubchannelDataType>* subchannel_data_;
186 RefCountedPtr<SubchannelList<SubchannelListType, SubchannelDataType>>
187 subchannel_list_;
188 const grpc_connectivity_state state_;
189 RefCountedPtr<ConnectedSubchannelInterface> connected_subchannel_;
190 grpc_closure closure_;
191 };
192
193 SubchannelData<SubchannelListType, SubchannelDataType>* subchannel_data_;
194 RefCountedPtr<SubchannelListType> subchannel_list_;
195 };
196
197 // Unrefs the subchannel.
198 void UnrefSubchannelLocked(const char* reason);
199
200 // Backpointer to owning subchannel list. Not owned.
201 SubchannelList<SubchannelListType, SubchannelDataType>* subchannel_list_;
202 // The subchannel.
203 RefCountedPtr<SubchannelInterface> subchannel_;
204 // Will be non-null when the subchannel's state is being watched.
205 SubchannelInterface::ConnectivityStateWatcher* pending_watcher_ = nullptr;
206 // Data updated by the watcher.
207 grpc_connectivity_state connectivity_state_;
208 RefCountedPtr<ConnectedSubchannelInterface> connected_subchannel_;
209 };
210
211 // A list of subchannels.
212 template <typename SubchannelListType, typename SubchannelDataType>
213 class SubchannelList : public InternallyRefCounted<SubchannelListType> {
214 public:
215 typedef InlinedVector<SubchannelDataType, 10> SubchannelVector;
216
217 // The number of subchannels in the list.
num_subchannels()218 size_t num_subchannels() const { return subchannels_.size(); }
219
220 // The data for the subchannel at a particular index.
subchannel(size_t index)221 SubchannelDataType* subchannel(size_t index) { return &subchannels_[index]; }
222
223 // Returns true if the subchannel list is shutting down.
shutting_down()224 bool shutting_down() const { return shutting_down_; }
225
226 // Accessors.
policy()227 LoadBalancingPolicy* policy() const { return policy_; }
tracer()228 TraceFlag* tracer() const { return tracer_; }
229
230 // Resets connection backoff of all subchannels.
231 // TODO(roth): We will probably need to rethink this as part of moving
232 // the backoff code out of subchannels and into LB policies.
233 void ResetBackoffLocked();
234
235 // Note: Caller must ensure that this is invoked inside of the combiner.
Orphan()236 void Orphan() override {
237 ShutdownLocked();
238 InternallyRefCounted<SubchannelListType>::Unref(DEBUG_LOCATION, "shutdown");
239 }
240
241 GRPC_ABSTRACT_BASE_CLASS
242
243 protected:
244 SubchannelList(LoadBalancingPolicy* policy, TraceFlag* tracer,
245 const ServerAddressList& addresses, grpc_combiner* combiner,
246 LoadBalancingPolicy::ChannelControlHelper* helper,
247 const grpc_channel_args& args);
248
249 virtual ~SubchannelList();
250
251 private:
252 // So New() can call our private ctor.
253 template <typename T, typename... Args>
254 friend T* New(Args&&... args);
255
256 // For accessing Ref() and Unref().
257 friend class SubchannelData<SubchannelListType, SubchannelDataType>;
258
259 void ShutdownLocked();
260
261 // Backpointer to owning policy.
262 LoadBalancingPolicy* policy_;
263
264 TraceFlag* tracer_;
265
266 grpc_combiner* combiner_;
267
268 // The list of subchannels.
269 SubchannelVector subchannels_;
270
271 // Is this list shutting down? This may be true due to the shutdown of the
272 // policy itself or because a newer update has arrived while this one hadn't
273 // finished processing.
274 bool shutting_down_ = false;
275 };
276
277 //
278 // implementation -- no user-servicable parts below
279 //
280
281 //
282 // SubchannelData::Watcher
283 //
284
285 template <typename SubchannelListType, typename SubchannelDataType>
286 void SubchannelData<SubchannelListType, SubchannelDataType>::Watcher::
OnConnectivityStateChange(grpc_connectivity_state new_state,RefCountedPtr<ConnectedSubchannelInterface> connected_subchannel)287 OnConnectivityStateChange(
288 grpc_connectivity_state new_state,
289 RefCountedPtr<ConnectedSubchannelInterface> connected_subchannel) {
290 // Will delete itself.
291 New<Updater>(subchannel_data_,
292 subchannel_list_->Ref(DEBUG_LOCATION, "Watcher::Updater"),
293 new_state, std::move(connected_subchannel));
294 }
295
296 template <typename SubchannelListType, typename SubchannelDataType>
297 SubchannelData<SubchannelListType, SubchannelDataType>::Watcher::Updater::
Updater(SubchannelData<SubchannelListType,SubchannelDataType> * subchannel_data,RefCountedPtr<SubchannelList<SubchannelListType,SubchannelDataType>> subchannel_list,grpc_connectivity_state state,RefCountedPtr<ConnectedSubchannelInterface> connected_subchannel)298 Updater(
299 SubchannelData<SubchannelListType, SubchannelDataType>* subchannel_data,
300 RefCountedPtr<SubchannelList<SubchannelListType, SubchannelDataType>>
301 subchannel_list,
302 grpc_connectivity_state state,
303 RefCountedPtr<ConnectedSubchannelInterface> connected_subchannel)
304 : subchannel_data_(subchannel_data),
305 subchannel_list_(std::move(subchannel_list)),
306 state_(state),
307 connected_subchannel_(std::move(connected_subchannel)) {
308 GRPC_CLOSURE_INIT(&closure_, &OnUpdateLocked, this,
309 grpc_combiner_scheduler(subchannel_list_->combiner_));
310 GRPC_CLOSURE_SCHED(&closure_, GRPC_ERROR_NONE);
311 }
312
313 template <typename SubchannelListType, typename SubchannelDataType>
314 void SubchannelData<SubchannelListType, SubchannelDataType>::Watcher::Updater::
OnUpdateLocked(void * arg,grpc_error * error)315 OnUpdateLocked(void* arg, grpc_error* error) {
316 Updater* self = static_cast<Updater*>(arg);
317 SubchannelData* sd = self->subchannel_data_;
318 if (GRPC_TRACE_FLAG_ENABLED(*sd->subchannel_list_->tracer())) {
319 gpr_log(GPR_INFO,
320 "[%s %p] subchannel list %p index %" PRIuPTR " of %" PRIuPTR
321 " (subchannel %p): connectivity changed: state=%s, "
322 "connected_subchannel=%p, shutting_down=%d, pending_watcher=%p",
323 sd->subchannel_list_->tracer()->name(),
324 sd->subchannel_list_->policy(), sd->subchannel_list_, sd->Index(),
325 sd->subchannel_list_->num_subchannels(), sd->subchannel_.get(),
326 grpc_connectivity_state_name(self->state_),
327 self->connected_subchannel_.get(),
328 sd->subchannel_list_->shutting_down(), sd->pending_watcher_);
329 }
330 if (!sd->subchannel_list_->shutting_down() &&
331 sd->pending_watcher_ != nullptr) {
332 sd->connectivity_state_ = self->state_;
333 // Get or release ref to connected subchannel.
334 sd->connected_subchannel_ = std::move(self->connected_subchannel_);
335 // Call the subclass's ProcessConnectivityChangeLocked() method.
336 sd->ProcessConnectivityChangeLocked(sd->connectivity_state_);
337 }
338 // Clean up.
339 Delete(self);
340 }
341
342 //
343 // SubchannelData
344 //
345
346 template <typename SubchannelListType, typename SubchannelDataType>
SubchannelData(SubchannelList<SubchannelListType,SubchannelDataType> * subchannel_list,const ServerAddress & address,RefCountedPtr<SubchannelInterface> subchannel)347 SubchannelData<SubchannelListType, SubchannelDataType>::SubchannelData(
348 SubchannelList<SubchannelListType, SubchannelDataType>* subchannel_list,
349 const ServerAddress& address, RefCountedPtr<SubchannelInterface> subchannel)
350 : subchannel_list_(subchannel_list),
351 subchannel_(std::move(subchannel)),
352 // We assume that the current state is IDLE. If not, we'll get a
353 // callback telling us that.
354 connectivity_state_(GRPC_CHANNEL_IDLE) {}
355
356 template <typename SubchannelListType, typename SubchannelDataType>
~SubchannelData()357 SubchannelData<SubchannelListType, SubchannelDataType>::~SubchannelData() {
358 GPR_ASSERT(subchannel_ == nullptr);
359 }
360
361 template <typename SubchannelListType, typename SubchannelDataType>
362 void SubchannelData<SubchannelListType, SubchannelDataType>::
UnrefSubchannelLocked(const char * reason)363 UnrefSubchannelLocked(const char* reason) {
364 if (subchannel_ != nullptr) {
365 if (GRPC_TRACE_FLAG_ENABLED(*subchannel_list_->tracer())) {
366 gpr_log(GPR_INFO,
367 "[%s %p] subchannel list %p index %" PRIuPTR " of %" PRIuPTR
368 " (subchannel %p): unreffing subchannel",
369 subchannel_list_->tracer()->name(), subchannel_list_->policy(),
370 subchannel_list_, Index(), subchannel_list_->num_subchannels(),
371 subchannel_.get());
372 }
373 subchannel_.reset();
374 connected_subchannel_.reset();
375 }
376 }
377
378 template <typename SubchannelListType, typename SubchannelDataType>
379 void SubchannelData<SubchannelListType,
ResetBackoffLocked()380 SubchannelDataType>::ResetBackoffLocked() {
381 if (subchannel_ != nullptr) {
382 subchannel_->ResetBackoff();
383 }
384 }
385
386 template <typename SubchannelListType, typename SubchannelDataType>
387 void SubchannelData<SubchannelListType,
StartConnectivityWatchLocked()388 SubchannelDataType>::StartConnectivityWatchLocked() {
389 if (GRPC_TRACE_FLAG_ENABLED(*subchannel_list_->tracer())) {
390 gpr_log(GPR_INFO,
391 "[%s %p] subchannel list %p index %" PRIuPTR " of %" PRIuPTR
392 " (subchannel %p): starting watch (from %s)",
393 subchannel_list_->tracer()->name(), subchannel_list_->policy(),
394 subchannel_list_, Index(), subchannel_list_->num_subchannels(),
395 subchannel_.get(),
396 grpc_connectivity_state_name(connectivity_state_));
397 }
398 GPR_ASSERT(pending_watcher_ == nullptr);
399 pending_watcher_ =
400 New<Watcher>(this, subchannel_list()->Ref(DEBUG_LOCATION, "Watcher"));
401 subchannel_->WatchConnectivityState(
402 connectivity_state_,
403 UniquePtr<SubchannelInterface::ConnectivityStateWatcher>(
404 pending_watcher_));
405 }
406
407 template <typename SubchannelListType, typename SubchannelDataType>
408 void SubchannelData<SubchannelListType, SubchannelDataType>::
CancelConnectivityWatchLocked(const char * reason)409 CancelConnectivityWatchLocked(const char* reason) {
410 if (GRPC_TRACE_FLAG_ENABLED(*subchannel_list_->tracer())) {
411 gpr_log(GPR_INFO,
412 "[%s %p] subchannel list %p index %" PRIuPTR " of %" PRIuPTR
413 " (subchannel %p): canceling connectivity watch (%s)",
414 subchannel_list_->tracer()->name(), subchannel_list_->policy(),
415 subchannel_list_, Index(), subchannel_list_->num_subchannels(),
416 subchannel_.get(), reason);
417 }
418 if (pending_watcher_ != nullptr) {
419 subchannel_->CancelConnectivityStateWatch(pending_watcher_);
420 pending_watcher_ = nullptr;
421 }
422 }
423
424 template <typename SubchannelListType, typename SubchannelDataType>
ShutdownLocked()425 void SubchannelData<SubchannelListType, SubchannelDataType>::ShutdownLocked() {
426 if (pending_watcher_ != nullptr) CancelConnectivityWatchLocked("shutdown");
427 UnrefSubchannelLocked("shutdown");
428 }
429
430 //
431 // SubchannelList
432 //
433
434 template <typename SubchannelListType, typename SubchannelDataType>
SubchannelList(LoadBalancingPolicy * policy,TraceFlag * tracer,const ServerAddressList & addresses,grpc_combiner * combiner,LoadBalancingPolicy::ChannelControlHelper * helper,const grpc_channel_args & args)435 SubchannelList<SubchannelListType, SubchannelDataType>::SubchannelList(
436 LoadBalancingPolicy* policy, TraceFlag* tracer,
437 const ServerAddressList& addresses, grpc_combiner* combiner,
438 LoadBalancingPolicy::ChannelControlHelper* helper,
439 const grpc_channel_args& args)
440 : InternallyRefCounted<SubchannelListType>(tracer),
441 policy_(policy),
442 tracer_(tracer),
443 combiner_(GRPC_COMBINER_REF(combiner, "subchannel_list")) {
444 if (GRPC_TRACE_FLAG_ENABLED(*tracer_)) {
445 gpr_log(GPR_INFO,
446 "[%s %p] Creating subchannel list %p for %" PRIuPTR " subchannels",
447 tracer_->name(), policy, this, addresses.size());
448 }
449 subchannels_.reserve(addresses.size());
450 // We need to remove the LB addresses in order to be able to compare the
451 // subchannel keys of subchannels from a different batch of addresses.
452 // We remove the service config, since it will be passed into the
453 // subchannel via call context.
454 static const char* keys_to_remove[] = {GRPC_ARG_SUBCHANNEL_ADDRESS,
455 GRPC_ARG_SERVICE_CONFIG};
456 // Create a subchannel for each address.
457 for (size_t i = 0; i < addresses.size(); i++) {
458 // TODO(roth): we should ideally hide this from the LB policy code. In
459 // principle, if we're dealing with this special case in the client_channel
460 // code for selecting grpclb, then we should also strip out these addresses
461 // there if we're not using grpclb.
462 if (addresses[i].IsBalancer()) {
463 continue;
464 }
465 InlinedVector<grpc_arg, 3> args_to_add;
466 const size_t subchannel_address_arg_index = args_to_add.size();
467 args_to_add.emplace_back(
468 Subchannel::CreateSubchannelAddressArg(&addresses[i].address()));
469 if (addresses[i].args() != nullptr) {
470 for (size_t j = 0; j < addresses[i].args()->num_args; ++j) {
471 args_to_add.emplace_back(addresses[i].args()->args[j]);
472 }
473 }
474 grpc_channel_args* new_args = grpc_channel_args_copy_and_add_and_remove(
475 &args, keys_to_remove, GPR_ARRAY_SIZE(keys_to_remove),
476 args_to_add.data(), args_to_add.size());
477 gpr_free(args_to_add[subchannel_address_arg_index].value.string);
478 RefCountedPtr<SubchannelInterface> subchannel =
479 helper->CreateSubchannel(*new_args);
480 grpc_channel_args_destroy(new_args);
481 if (subchannel == nullptr) {
482 // Subchannel could not be created.
483 if (GRPC_TRACE_FLAG_ENABLED(*tracer_)) {
484 char* address_uri = grpc_sockaddr_to_uri(&addresses[i].address());
485 gpr_log(GPR_INFO,
486 "[%s %p] could not create subchannel for address uri %s, "
487 "ignoring",
488 tracer_->name(), policy_, address_uri);
489 gpr_free(address_uri);
490 }
491 continue;
492 }
493 if (GRPC_TRACE_FLAG_ENABLED(*tracer_)) {
494 char* address_uri = grpc_sockaddr_to_uri(&addresses[i].address());
495 gpr_log(GPR_INFO,
496 "[%s %p] subchannel list %p index %" PRIuPTR
497 ": Created subchannel %p for address uri %s",
498 tracer_->name(), policy_, this, subchannels_.size(),
499 subchannel.get(), address_uri);
500 gpr_free(address_uri);
501 }
502 subchannels_.emplace_back(this, addresses[i], std::move(subchannel));
503 }
504 }
505
506 template <typename SubchannelListType, typename SubchannelDataType>
~SubchannelList()507 SubchannelList<SubchannelListType, SubchannelDataType>::~SubchannelList() {
508 if (GRPC_TRACE_FLAG_ENABLED(*tracer_)) {
509 gpr_log(GPR_INFO, "[%s %p] Destroying subchannel_list %p", tracer_->name(),
510 policy_, this);
511 }
512 GRPC_COMBINER_UNREF(combiner_, "subchannel_list");
513 }
514
515 template <typename SubchannelListType, typename SubchannelDataType>
ShutdownLocked()516 void SubchannelList<SubchannelListType, SubchannelDataType>::ShutdownLocked() {
517 if (GRPC_TRACE_FLAG_ENABLED(*tracer_)) {
518 gpr_log(GPR_INFO, "[%s %p] Shutting down subchannel_list %p",
519 tracer_->name(), policy_, this);
520 }
521 GPR_ASSERT(!shutting_down_);
522 shutting_down_ = true;
523 for (size_t i = 0; i < subchannels_.size(); i++) {
524 SubchannelDataType* sd = &subchannels_[i];
525 sd->ShutdownLocked();
526 }
527 }
528
529 template <typename SubchannelListType, typename SubchannelDataType>
530 void SubchannelList<SubchannelListType,
ResetBackoffLocked()531 SubchannelDataType>::ResetBackoffLocked() {
532 for (size_t i = 0; i < subchannels_.size(); i++) {
533 SubchannelDataType* sd = &subchannels_[i];
534 sd->ResetBackoffLocked();
535 }
536 }
537
538 } // namespace grpc_core
539
540 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_SUBCHANNEL_LIST_H */
541