|
|
|
|
@ -133,7 +133,7 @@ grpc_tracer_flag grpc_lb_glb_trace = GRPC_TRACER_INITIALIZER(false, "glb"); |
|
|
|
|
static grpc_error* initial_metadata_add_lb_token( |
|
|
|
|
grpc_exec_ctx* exec_ctx, grpc_metadata_batch* initial_metadata, |
|
|
|
|
grpc_linked_mdelem* lb_token_mdelem_storage, grpc_mdelem lb_token) { |
|
|
|
|
GPR_ASSERT(lb_token_mdelem_storage != NULL); |
|
|
|
|
GPR_ASSERT(lb_token_mdelem_storage != nullptr); |
|
|
|
|
GPR_ASSERT(!GRPC_MDISNULL(lb_token)); |
|
|
|
|
return grpc_metadata_batch_add_tail(exec_ctx, initial_metadata, |
|
|
|
|
lb_token_mdelem_storage, lb_token); |
|
|
|
|
@ -190,14 +190,14 @@ static void wrapped_rr_closure(grpc_exec_ctx* exec_ctx, void* arg, |
|
|
|
|
grpc_error* error) { |
|
|
|
|
wrapped_rr_closure_arg* wc_arg = (wrapped_rr_closure_arg*)arg; |
|
|
|
|
|
|
|
|
|
GPR_ASSERT(wc_arg->wrapped_closure != NULL); |
|
|
|
|
GPR_ASSERT(wc_arg->wrapped_closure != nullptr); |
|
|
|
|
GRPC_CLOSURE_SCHED(exec_ctx, wc_arg->wrapped_closure, GRPC_ERROR_REF(error)); |
|
|
|
|
|
|
|
|
|
if (wc_arg->rr_policy != NULL) { |
|
|
|
|
if (wc_arg->rr_policy != nullptr) { |
|
|
|
|
/* if *target is NULL, no pick has been made by the RR policy (eg, all
|
|
|
|
|
* addresses failed to connect). There won't be any user_data/token |
|
|
|
|
* available */ |
|
|
|
|
if (*wc_arg->target != NULL) { |
|
|
|
|
if (*wc_arg->target != nullptr) { |
|
|
|
|
if (!GRPC_MDISNULL(wc_arg->lb_token)) { |
|
|
|
|
initial_metadata_add_lb_token(exec_ctx, wc_arg->initial_metadata, |
|
|
|
|
wc_arg->lb_token_mdelem_storage, |
|
|
|
|
@ -211,7 +211,7 @@ static void wrapped_rr_closure(grpc_exec_ctx* exec_ctx, void* arg, |
|
|
|
|
abort(); |
|
|
|
|
} |
|
|
|
|
// Pass on client stats via context. Passes ownership of the reference.
|
|
|
|
|
GPR_ASSERT(wc_arg->client_stats != NULL); |
|
|
|
|
GPR_ASSERT(wc_arg->client_stats != nullptr); |
|
|
|
|
wc_arg->context[GRPC_GRPCLB_CLIENT_STATS].value = wc_arg->client_stats; |
|
|
|
|
wc_arg->context[GRPC_GRPCLB_CLIENT_STATS].destroy = destroy_client_stats; |
|
|
|
|
} else { |
|
|
|
|
@ -223,7 +223,7 @@ static void wrapped_rr_closure(grpc_exec_ctx* exec_ctx, void* arg, |
|
|
|
|
} |
|
|
|
|
GRPC_LB_POLICY_UNREF(exec_ctx, wc_arg->rr_policy, "wrapped_rr_closure"); |
|
|
|
|
} |
|
|
|
|
GPR_ASSERT(wc_arg->free_when_done != NULL); |
|
|
|
|
GPR_ASSERT(wc_arg->free_when_done != nullptr); |
|
|
|
|
gpr_free(wc_arg->free_when_done); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -455,12 +455,12 @@ static bool is_server_valid(const grpc_grpclb_server* server, size_t idx, |
|
|
|
|
|
|
|
|
|
/* vtable for LB tokens in grpc_lb_addresses. */ |
|
|
|
|
static void* lb_token_copy(void* token) { |
|
|
|
|
return token == NULL |
|
|
|
|
? NULL |
|
|
|
|
return token == nullptr |
|
|
|
|
? nullptr |
|
|
|
|
: (void*)GRPC_MDELEM_REF(grpc_mdelem{(uintptr_t)token}).payload; |
|
|
|
|
} |
|
|
|
|
static void lb_token_destroy(grpc_exec_ctx* exec_ctx, void* token) { |
|
|
|
|
if (token != NULL) { |
|
|
|
|
if (token != nullptr) { |
|
|
|
|
GRPC_MDELEM_UNREF(exec_ctx, grpc_mdelem{(uintptr_t)token}); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
@ -543,7 +543,7 @@ static grpc_lb_addresses* process_serverlist_locked( |
|
|
|
|
|
|
|
|
|
grpc_lb_addresses_set_address(lb_addresses, addr_idx, &addr.addr, addr.len, |
|
|
|
|
false /* is_balancer */, |
|
|
|
|
NULL /* balancer_name */, user_data); |
|
|
|
|
nullptr /* balancer_name */, user_data); |
|
|
|
|
++addr_idx; |
|
|
|
|
} |
|
|
|
|
GPR_ASSERT(addr_idx == num_valid); |
|
|
|
|
@ -569,7 +569,7 @@ static grpc_lb_addresses* extract_backend_addresses_locked( |
|
|
|
|
const grpc_resolved_address* addr = &addresses->addresses[i].address; |
|
|
|
|
grpc_lb_addresses_set_address(backend_addresses, num_copied, &addr->addr, |
|
|
|
|
addr->len, false /* is_balancer */, |
|
|
|
|
NULL /* balancer_name */, |
|
|
|
|
nullptr /* balancer_name */, |
|
|
|
|
(void*)GRPC_MDELEM_LB_TOKEN_EMPTY.payload); |
|
|
|
|
++num_copied; |
|
|
|
|
} |
|
|
|
|
@ -645,7 +645,7 @@ static bool pick_from_internal_rr_locked( |
|
|
|
|
const grpc_lb_policy_pick_args* pick_args, bool force_async, |
|
|
|
|
grpc_connected_subchannel** target, wrapped_rr_closure_arg* wc_arg) { |
|
|
|
|
// Check for drops if we are not using fallback backend addresses.
|
|
|
|
|
if (glb_policy->serverlist != NULL) { |
|
|
|
|
if (glb_policy->serverlist != nullptr) { |
|
|
|
|
// Look at the index into the serverlist to see if we should drop this call.
|
|
|
|
|
grpc_grpclb_server* server = |
|
|
|
|
glb_policy->serverlist->servers[glb_policy->serverlist_index++]; |
|
|
|
|
@ -664,12 +664,12 @@ static bool pick_from_internal_rr_locked( |
|
|
|
|
// the client_load_reporting filter, because we do not create a
|
|
|
|
|
// subchannel call (and therefore no client_load_reporting filter)
|
|
|
|
|
// for dropped calls.
|
|
|
|
|
GPR_ASSERT(wc_arg->client_stats != NULL); |
|
|
|
|
GPR_ASSERT(wc_arg->client_stats != nullptr); |
|
|
|
|
grpc_grpclb_client_stats_add_call_dropped_locked( |
|
|
|
|
server->load_balance_token, wc_arg->client_stats); |
|
|
|
|
grpc_grpclb_client_stats_unref(wc_arg->client_stats); |
|
|
|
|
if (force_async) { |
|
|
|
|
GPR_ASSERT(wc_arg->wrapped_closure != NULL); |
|
|
|
|
GPR_ASSERT(wc_arg->wrapped_closure != nullptr); |
|
|
|
|
GRPC_CLOSURE_SCHED(exec_ctx, wc_arg->wrapped_closure, GRPC_ERROR_NONE); |
|
|
|
|
gpr_free(wc_arg->free_when_done); |
|
|
|
|
return false; |
|
|
|
|
@ -694,11 +694,11 @@ static bool pick_from_internal_rr_locked( |
|
|
|
|
pick_args->lb_token_mdelem_storage, |
|
|
|
|
GRPC_MDELEM_REF(wc_arg->lb_token)); |
|
|
|
|
// Pass on client stats via context. Passes ownership of the reference.
|
|
|
|
|
GPR_ASSERT(wc_arg->client_stats != NULL); |
|
|
|
|
GPR_ASSERT(wc_arg->client_stats != nullptr); |
|
|
|
|
wc_arg->context[GRPC_GRPCLB_CLIENT_STATS].value = wc_arg->client_stats; |
|
|
|
|
wc_arg->context[GRPC_GRPCLB_CLIENT_STATS].destroy = destroy_client_stats; |
|
|
|
|
if (force_async) { |
|
|
|
|
GPR_ASSERT(wc_arg->wrapped_closure != NULL); |
|
|
|
|
GPR_ASSERT(wc_arg->wrapped_closure != nullptr); |
|
|
|
|
GRPC_CLOSURE_SCHED(exec_ctx, wc_arg->wrapped_closure, GRPC_ERROR_NONE); |
|
|
|
|
gpr_free(wc_arg->free_when_done); |
|
|
|
|
return false; |
|
|
|
|
@ -715,7 +715,7 @@ static bool pick_from_internal_rr_locked( |
|
|
|
|
static grpc_lb_policy_args* lb_policy_args_create(grpc_exec_ctx* exec_ctx, |
|
|
|
|
glb_lb_policy* glb_policy) { |
|
|
|
|
grpc_lb_addresses* addresses; |
|
|
|
|
if (glb_policy->serverlist != NULL) { |
|
|
|
|
if (glb_policy->serverlist != nullptr) { |
|
|
|
|
GPR_ASSERT(glb_policy->serverlist->num_servers > 0); |
|
|
|
|
addresses = process_serverlist_locked(exec_ctx, glb_policy->serverlist); |
|
|
|
|
} else { |
|
|
|
|
@ -723,10 +723,10 @@ static grpc_lb_policy_args* lb_policy_args_create(grpc_exec_ctx* exec_ctx, |
|
|
|
|
// serverlist from the balancer, we use the fallback backends returned by
|
|
|
|
|
// the resolver. Note that the fallback backend list may be empty, in which
|
|
|
|
|
// case the new round_robin policy will keep the requested picks pending.
|
|
|
|
|
GPR_ASSERT(glb_policy->fallback_backend_addresses != NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->fallback_backend_addresses != nullptr); |
|
|
|
|
addresses = grpc_lb_addresses_copy(glb_policy->fallback_backend_addresses); |
|
|
|
|
} |
|
|
|
|
GPR_ASSERT(addresses != NULL); |
|
|
|
|
GPR_ASSERT(addresses != nullptr); |
|
|
|
|
grpc_lb_policy_args* args = (grpc_lb_policy_args*)gpr_zalloc(sizeof(*args)); |
|
|
|
|
args->client_channel_factory = glb_policy->cc_factory; |
|
|
|
|
args->combiner = glb_policy->base.combiner; |
|
|
|
|
@ -751,11 +751,11 @@ static void glb_rr_connectivity_changed_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
void* arg, grpc_error* error); |
|
|
|
|
static void create_rr_locked(grpc_exec_ctx* exec_ctx, glb_lb_policy* glb_policy, |
|
|
|
|
grpc_lb_policy_args* args) { |
|
|
|
|
GPR_ASSERT(glb_policy->rr_policy == NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->rr_policy == nullptr); |
|
|
|
|
|
|
|
|
|
grpc_lb_policy* new_rr_policy = |
|
|
|
|
grpc_lb_policy_create(exec_ctx, "round_robin", args); |
|
|
|
|
if (new_rr_policy == NULL) { |
|
|
|
|
if (new_rr_policy == nullptr) { |
|
|
|
|
gpr_log(GPR_ERROR, |
|
|
|
|
"[grpclb %p] Failure creating a RoundRobin policy for serverlist " |
|
|
|
|
"update with %" PRIuPTR |
|
|
|
|
@ -767,7 +767,7 @@ static void create_rr_locked(grpc_exec_ctx* exec_ctx, glb_lb_policy* glb_policy, |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
glb_policy->rr_policy = new_rr_policy; |
|
|
|
|
grpc_error* rr_state_error = NULL; |
|
|
|
|
grpc_error* rr_state_error = nullptr; |
|
|
|
|
const grpc_connectivity_state rr_state = |
|
|
|
|
grpc_lb_policy_check_connectivity_locked(exec_ctx, glb_policy->rr_policy, |
|
|
|
|
&rr_state_error); |
|
|
|
|
@ -835,8 +835,8 @@ static void rr_handover_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
glb_lb_policy* glb_policy) { |
|
|
|
|
if (glb_policy->shutting_down) return; |
|
|
|
|
grpc_lb_policy_args* args = lb_policy_args_create(exec_ctx, glb_policy); |
|
|
|
|
GPR_ASSERT(args != NULL); |
|
|
|
|
if (glb_policy->rr_policy != NULL) { |
|
|
|
|
GPR_ASSERT(args != nullptr); |
|
|
|
|
if (glb_policy->rr_policy != nullptr) { |
|
|
|
|
if (GRPC_TRACER_ON(grpc_lb_glb_trace)) { |
|
|
|
|
gpr_log(GPR_DEBUG, "[grpclb %p] Updating RR policy %p", glb_policy, |
|
|
|
|
glb_policy->rr_policy); |
|
|
|
|
@ -868,7 +868,7 @@ static void glb_rr_connectivity_changed_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
* sink, policies can't transition back from it. .*/ |
|
|
|
|
GRPC_LB_POLICY_UNREF(exec_ctx, glb_policy->rr_policy, |
|
|
|
|
"rr_connectivity_shutdown"); |
|
|
|
|
glb_policy->rr_policy = NULL; |
|
|
|
|
glb_policy->rr_policy = nullptr; |
|
|
|
|
GRPC_LB_POLICY_WEAK_UNREF(exec_ctx, &glb_policy->base, |
|
|
|
|
"glb_rr_connectivity_cb"); |
|
|
|
|
gpr_free(rr_connectivity); |
|
|
|
|
@ -923,7 +923,7 @@ static grpc_channel_args* build_lb_channel_args( |
|
|
|
|
* instantiated and used in that case. Otherwise, something has gone wrong. */ |
|
|
|
|
GPR_ASSERT(num_grpclb_addrs > 0); |
|
|
|
|
grpc_lb_addresses* lb_addresses = |
|
|
|
|
grpc_lb_addresses_create(num_grpclb_addrs, NULL); |
|
|
|
|
grpc_lb_addresses_create(num_grpclb_addrs, nullptr); |
|
|
|
|
grpc_slice_hash_table_entry* targets_info_entries = |
|
|
|
|
(grpc_slice_hash_table_entry*)gpr_zalloc(sizeof(*targets_info_entries) * |
|
|
|
|
num_grpclb_addrs); |
|
|
|
|
@ -931,7 +931,7 @@ static grpc_channel_args* build_lb_channel_args( |
|
|
|
|
size_t lb_addresses_idx = 0; |
|
|
|
|
for (size_t i = 0; i < addresses->num_addresses; ++i) { |
|
|
|
|
if (!addresses->addresses[i].is_balancer) continue; |
|
|
|
|
if (addresses->addresses[i].user_data != NULL) { |
|
|
|
|
if (addresses->addresses[i].user_data != nullptr) { |
|
|
|
|
gpr_log(GPR_ERROR, |
|
|
|
|
"This LB policy doesn't support user data. It will be ignored"); |
|
|
|
|
} |
|
|
|
|
@ -945,7 +945,7 @@ static grpc_channel_args* build_lb_channel_args( |
|
|
|
|
grpc_lb_addresses_set_address( |
|
|
|
|
lb_addresses, lb_addresses_idx++, addresses->addresses[i].address.addr, |
|
|
|
|
addresses->addresses[i].address.len, false /* is balancer */, |
|
|
|
|
addresses->addresses[i].balancer_name, NULL /* user data */); |
|
|
|
|
addresses->addresses[i].balancer_name, nullptr /* user data */); |
|
|
|
|
} |
|
|
|
|
GPR_ASSERT(num_grpclb_addrs == lb_addresses_idx); |
|
|
|
|
grpc_slice_hash_table* targets_info = |
|
|
|
|
@ -970,18 +970,18 @@ static grpc_channel_args* build_lb_channel_args( |
|
|
|
|
|
|
|
|
|
static void glb_destroy(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol) { |
|
|
|
|
glb_lb_policy* glb_policy = (glb_lb_policy*)pol; |
|
|
|
|
GPR_ASSERT(glb_policy->pending_picks == NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->pending_pings == NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->pending_picks == nullptr); |
|
|
|
|
GPR_ASSERT(glb_policy->pending_pings == nullptr); |
|
|
|
|
gpr_free((void*)glb_policy->server_name); |
|
|
|
|
grpc_channel_args_destroy(exec_ctx, glb_policy->args); |
|
|
|
|
if (glb_policy->client_stats != NULL) { |
|
|
|
|
if (glb_policy->client_stats != nullptr) { |
|
|
|
|
grpc_grpclb_client_stats_unref(glb_policy->client_stats); |
|
|
|
|
} |
|
|
|
|
grpc_connectivity_state_destroy(exec_ctx, &glb_policy->state_tracker); |
|
|
|
|
if (glb_policy->serverlist != NULL) { |
|
|
|
|
if (glb_policy->serverlist != nullptr) { |
|
|
|
|
grpc_grpclb_destroy_serverlist(glb_policy->serverlist); |
|
|
|
|
} |
|
|
|
|
if (glb_policy->fallback_backend_addresses != NULL) { |
|
|
|
|
if (glb_policy->fallback_backend_addresses != nullptr) { |
|
|
|
|
grpc_lb_addresses_destroy(exec_ctx, glb_policy->fallback_backend_addresses); |
|
|
|
|
} |
|
|
|
|
grpc_fake_resolver_response_generator_unref(glb_policy->response_generator); |
|
|
|
|
@ -1002,8 +1002,8 @@ static void glb_shutdown_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol) { |
|
|
|
|
* because glb_policy->lb_call is only assigned in lb_call_init_locked as part |
|
|
|
|
* of query_for_backends_locked, which can only be invoked while |
|
|
|
|
* glb_policy->shutting_down is false. */ |
|
|
|
|
if (lb_call != NULL) { |
|
|
|
|
grpc_call_cancel(lb_call, NULL); |
|
|
|
|
if (lb_call != nullptr) { |
|
|
|
|
grpc_call_cancel(lb_call, nullptr); |
|
|
|
|
/* lb_on_server_status_received will pick up the cancel and clean up */ |
|
|
|
|
} |
|
|
|
|
if (glb_policy->retry_timer_active) { |
|
|
|
|
@ -1016,27 +1016,27 @@ static void glb_shutdown_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol) { |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
pending_pick* pp = glb_policy->pending_picks; |
|
|
|
|
glb_policy->pending_picks = NULL; |
|
|
|
|
glb_policy->pending_picks = nullptr; |
|
|
|
|
pending_ping* pping = glb_policy->pending_pings; |
|
|
|
|
glb_policy->pending_pings = NULL; |
|
|
|
|
if (glb_policy->rr_policy != NULL) { |
|
|
|
|
glb_policy->pending_pings = nullptr; |
|
|
|
|
if (glb_policy->rr_policy != nullptr) { |
|
|
|
|
GRPC_LB_POLICY_UNREF(exec_ctx, glb_policy->rr_policy, "glb_shutdown"); |
|
|
|
|
} |
|
|
|
|
// We destroy the LB channel here because
|
|
|
|
|
// glb_lb_channel_on_connectivity_changed_cb needs a valid glb_policy
|
|
|
|
|
// instance. Destroying the lb channel in glb_destroy would likely result in
|
|
|
|
|
// a callback invocation without a valid glb_policy arg.
|
|
|
|
|
if (glb_policy->lb_channel != NULL) { |
|
|
|
|
if (glb_policy->lb_channel != nullptr) { |
|
|
|
|
grpc_channel_destroy(glb_policy->lb_channel); |
|
|
|
|
glb_policy->lb_channel = NULL; |
|
|
|
|
glb_policy->lb_channel = nullptr; |
|
|
|
|
} |
|
|
|
|
grpc_connectivity_state_set( |
|
|
|
|
exec_ctx, &glb_policy->state_tracker, GRPC_CHANNEL_SHUTDOWN, |
|
|
|
|
GRPC_ERROR_CREATE_FROM_STATIC_STRING("Channel Shutdown"), "glb_shutdown"); |
|
|
|
|
|
|
|
|
|
while (pp != NULL) { |
|
|
|
|
while (pp != nullptr) { |
|
|
|
|
pending_pick* next = pp->next; |
|
|
|
|
*pp->target = NULL; |
|
|
|
|
*pp->target = nullptr; |
|
|
|
|
GRPC_CLOSURE_SCHED( |
|
|
|
|
exec_ctx, &pp->wrapped_on_complete_arg.wrapper_closure, |
|
|
|
|
GRPC_ERROR_CREATE_FROM_STATIC_STRING("Channel Shutdown")); |
|
|
|
|
@ -1044,7 +1044,7 @@ static void glb_shutdown_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol) { |
|
|
|
|
pp = next; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
while (pping != NULL) { |
|
|
|
|
while (pping != nullptr) { |
|
|
|
|
pending_ping* next = pping->next; |
|
|
|
|
GRPC_CLOSURE_SCHED( |
|
|
|
|
exec_ctx, &pping->wrapped_notify_arg.wrapper_closure, |
|
|
|
|
@ -1069,11 +1069,11 @@ static void glb_cancel_pick_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol, |
|
|
|
|
grpc_error* error) { |
|
|
|
|
glb_lb_policy* glb_policy = (glb_lb_policy*)pol; |
|
|
|
|
pending_pick* pp = glb_policy->pending_picks; |
|
|
|
|
glb_policy->pending_picks = NULL; |
|
|
|
|
while (pp != NULL) { |
|
|
|
|
glb_policy->pending_picks = nullptr; |
|
|
|
|
while (pp != nullptr) { |
|
|
|
|
pending_pick* next = pp->next; |
|
|
|
|
if (pp->target == target) { |
|
|
|
|
*target = NULL; |
|
|
|
|
*target = nullptr; |
|
|
|
|
GRPC_CLOSURE_SCHED(exec_ctx, &pp->wrapped_on_complete_arg.wrapper_closure, |
|
|
|
|
GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( |
|
|
|
|
"Pick Cancelled", &error, 1)); |
|
|
|
|
@ -1083,7 +1083,7 @@ static void glb_cancel_pick_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol, |
|
|
|
|
} |
|
|
|
|
pp = next; |
|
|
|
|
} |
|
|
|
|
if (glb_policy->rr_policy != NULL) { |
|
|
|
|
if (glb_policy->rr_policy != nullptr) { |
|
|
|
|
grpc_lb_policy_cancel_pick_locked(exec_ctx, glb_policy->rr_policy, target, |
|
|
|
|
GRPC_ERROR_REF(error)); |
|
|
|
|
} |
|
|
|
|
@ -1107,8 +1107,8 @@ static void glb_cancel_picks_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
grpc_error* error) { |
|
|
|
|
glb_lb_policy* glb_policy = (glb_lb_policy*)pol; |
|
|
|
|
pending_pick* pp = glb_policy->pending_picks; |
|
|
|
|
glb_policy->pending_picks = NULL; |
|
|
|
|
while (pp != NULL) { |
|
|
|
|
glb_policy->pending_picks = nullptr; |
|
|
|
|
while (pp != nullptr) { |
|
|
|
|
pending_pick* next = pp->next; |
|
|
|
|
if ((pp->pick_args.initial_metadata_flags & initial_metadata_flags_mask) == |
|
|
|
|
initial_metadata_flags_eq) { |
|
|
|
|
@ -1121,7 +1121,7 @@ static void glb_cancel_picks_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
} |
|
|
|
|
pp = next; |
|
|
|
|
} |
|
|
|
|
if (glb_policy->rr_policy != NULL) { |
|
|
|
|
if (glb_policy->rr_policy != nullptr) { |
|
|
|
|
grpc_lb_policy_cancel_picks_locked( |
|
|
|
|
exec_ctx, glb_policy->rr_policy, initial_metadata_flags_mask, |
|
|
|
|
initial_metadata_flags_eq, GRPC_ERROR_REF(error)); |
|
|
|
|
@ -1137,7 +1137,7 @@ static void start_picking_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
glb_lb_policy* glb_policy) { |
|
|
|
|
/* start a timer to fall back */ |
|
|
|
|
if (glb_policy->lb_fallback_timeout_ms > 0 && |
|
|
|
|
glb_policy->serverlist == NULL && !glb_policy->fallback_timer_active) { |
|
|
|
|
glb_policy->serverlist == nullptr && !glb_policy->fallback_timer_active) { |
|
|
|
|
grpc_millis deadline = |
|
|
|
|
grpc_exec_ctx_now(exec_ctx) + glb_policy->lb_fallback_timeout_ms; |
|
|
|
|
GRPC_LB_POLICY_WEAK_REF(&glb_policy->base, "grpclb_fallback_timer"); |
|
|
|
|
@ -1166,8 +1166,8 @@ static int glb_pick_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol, |
|
|
|
|
grpc_connected_subchannel** target, |
|
|
|
|
grpc_call_context_element* context, void** user_data, |
|
|
|
|
grpc_closure* on_complete) { |
|
|
|
|
if (pick_args->lb_token_mdelem_storage == NULL) { |
|
|
|
|
*target = NULL; |
|
|
|
|
if (pick_args->lb_token_mdelem_storage == nullptr) { |
|
|
|
|
*target = nullptr; |
|
|
|
|
GRPC_CLOSURE_SCHED(exec_ctx, on_complete, |
|
|
|
|
GRPC_ERROR_CREATE_FROM_STATIC_STRING( |
|
|
|
|
"No mdelem storage for the LB token. Load reporting " |
|
|
|
|
@ -1176,10 +1176,10 @@ static int glb_pick_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol, |
|
|
|
|
} |
|
|
|
|
glb_lb_policy* glb_policy = (glb_lb_policy*)pol; |
|
|
|
|
bool pick_done = false; |
|
|
|
|
if (glb_policy->rr_policy != NULL) { |
|
|
|
|
if (glb_policy->rr_policy != nullptr) { |
|
|
|
|
const grpc_connectivity_state rr_connectivity_state = |
|
|
|
|
grpc_lb_policy_check_connectivity_locked(exec_ctx, |
|
|
|
|
glb_policy->rr_policy, NULL); |
|
|
|
|
grpc_lb_policy_check_connectivity_locked( |
|
|
|
|
exec_ctx, glb_policy->rr_policy, nullptr); |
|
|
|
|
// The glb_policy->rr_policy may have transitioned to SHUTDOWN but the
|
|
|
|
|
// callback registered to capture this event
|
|
|
|
|
// (glb_rr_connectivity_changed_locked) may not have been invoked yet. We
|
|
|
|
|
@ -1208,7 +1208,7 @@ static int glb_pick_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol, |
|
|
|
|
wc_arg->rr_policy = glb_policy->rr_policy; |
|
|
|
|
wc_arg->target = target; |
|
|
|
|
wc_arg->context = context; |
|
|
|
|
GPR_ASSERT(glb_policy->client_stats != NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->client_stats != nullptr); |
|
|
|
|
wc_arg->client_stats = |
|
|
|
|
grpc_grpclb_client_stats_ref(glb_policy->client_stats); |
|
|
|
|
wc_arg->wrapped_closure = on_complete; |
|
|
|
|
@ -1270,7 +1270,7 @@ static void lb_call_on_retry_timer_locked(grpc_exec_ctx* exec_ctx, void* arg, |
|
|
|
|
grpc_error* error) { |
|
|
|
|
glb_lb_policy* glb_policy = (glb_lb_policy*)arg; |
|
|
|
|
glb_policy->retry_timer_active = false; |
|
|
|
|
if (!glb_policy->shutting_down && glb_policy->lb_call == NULL && |
|
|
|
|
if (!glb_policy->shutting_down && glb_policy->lb_call == nullptr && |
|
|
|
|
error == GRPC_ERROR_NONE) { |
|
|
|
|
if (GRPC_TRACER_ON(grpc_lb_glb_trace)) { |
|
|
|
|
gpr_log(GPR_INFO, "[grpclb %p] Restarting call to LB server", glb_policy); |
|
|
|
|
@ -1337,8 +1337,8 @@ static void client_load_report_done_locked(grpc_exec_ctx* exec_ctx, void* arg, |
|
|
|
|
grpc_error* error) { |
|
|
|
|
glb_lb_policy* glb_policy = (glb_lb_policy*)arg; |
|
|
|
|
grpc_byte_buffer_destroy(glb_policy->client_load_report_payload); |
|
|
|
|
glb_policy->client_load_report_payload = NULL; |
|
|
|
|
if (error != GRPC_ERROR_NONE || glb_policy->lb_call == NULL) { |
|
|
|
|
glb_policy->client_load_report_payload = nullptr; |
|
|
|
|
if (error != GRPC_ERROR_NONE || glb_policy->lb_call == nullptr) { |
|
|
|
|
glb_policy->client_load_report_timer_pending = false; |
|
|
|
|
GRPC_LB_POLICY_WEAK_UNREF(exec_ctx, &glb_policy->base, |
|
|
|
|
"client_load_report"); |
|
|
|
|
@ -1356,23 +1356,23 @@ static bool load_report_counters_are_zero(grpc_grpclb_request* request) { |
|
|
|
|
request->client_stats.num_calls_finished_with_client_failed_to_send == |
|
|
|
|
0 && |
|
|
|
|
request->client_stats.num_calls_finished_known_received == 0 && |
|
|
|
|
(drop_entries == NULL || drop_entries->num_entries == 0); |
|
|
|
|
(drop_entries == nullptr || drop_entries->num_entries == 0); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static void send_client_load_report_locked(grpc_exec_ctx* exec_ctx, void* arg, |
|
|
|
|
grpc_error* error) { |
|
|
|
|
glb_lb_policy* glb_policy = (glb_lb_policy*)arg; |
|
|
|
|
if (error == GRPC_ERROR_CANCELLED || glb_policy->lb_call == NULL) { |
|
|
|
|
if (error == GRPC_ERROR_CANCELLED || glb_policy->lb_call == nullptr) { |
|
|
|
|
glb_policy->client_load_report_timer_pending = false; |
|
|
|
|
GRPC_LB_POLICY_WEAK_UNREF(exec_ctx, &glb_policy->base, |
|
|
|
|
"client_load_report"); |
|
|
|
|
if (glb_policy->lb_call == NULL) { |
|
|
|
|
if (glb_policy->lb_call == nullptr) { |
|
|
|
|
maybe_restart_lb_call(exec_ctx, glb_policy); |
|
|
|
|
} |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
// Construct message payload.
|
|
|
|
|
GPR_ASSERT(glb_policy->client_load_report_payload == NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->client_load_report_payload == nullptr); |
|
|
|
|
grpc_grpclb_request* request = |
|
|
|
|
grpc_grpclb_load_report_request_create_locked(glb_policy->client_stats); |
|
|
|
|
// Skip client load report if the counters were all zero in the last
|
|
|
|
|
@ -1415,9 +1415,9 @@ static void lb_on_response_received_locked(grpc_exec_ctx* exec_ctx, void* arg, |
|
|
|
|
grpc_error* error); |
|
|
|
|
static void lb_call_init_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
glb_lb_policy* glb_policy) { |
|
|
|
|
GPR_ASSERT(glb_policy->server_name != NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->server_name != nullptr); |
|
|
|
|
GPR_ASSERT(glb_policy->server_name[0] != '\0'); |
|
|
|
|
GPR_ASSERT(glb_policy->lb_call == NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->lb_call == nullptr); |
|
|
|
|
GPR_ASSERT(!glb_policy->shutting_down); |
|
|
|
|
|
|
|
|
|
/* Note the following LB call progresses every time there's activity in \a
|
|
|
|
|
@ -1429,13 +1429,13 @@ static void lb_call_init_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
? GRPC_MILLIS_INF_FUTURE |
|
|
|
|
: grpc_exec_ctx_now(exec_ctx) + glb_policy->lb_call_timeout_ms; |
|
|
|
|
glb_policy->lb_call = grpc_channel_create_pollset_set_call( |
|
|
|
|
exec_ctx, glb_policy->lb_channel, NULL, GRPC_PROPAGATE_DEFAULTS, |
|
|
|
|
exec_ctx, glb_policy->lb_channel, nullptr, GRPC_PROPAGATE_DEFAULTS, |
|
|
|
|
glb_policy->base.interested_parties, |
|
|
|
|
GRPC_MDSTR_SLASH_GRPC_DOT_LB_DOT_V1_DOT_LOADBALANCER_SLASH_BALANCELOAD, |
|
|
|
|
&host, deadline, NULL); |
|
|
|
|
&host, deadline, nullptr); |
|
|
|
|
grpc_slice_unref_internal(exec_ctx, host); |
|
|
|
|
|
|
|
|
|
if (glb_policy->client_stats != NULL) { |
|
|
|
|
if (glb_policy->client_stats != nullptr) { |
|
|
|
|
grpc_grpclb_client_stats_unref(glb_policy->client_stats); |
|
|
|
|
} |
|
|
|
|
glb_policy->client_stats = grpc_grpclb_client_stats_create(); |
|
|
|
|
@ -1471,9 +1471,9 @@ static void lb_call_init_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
|
|
|
|
|
static void lb_call_destroy_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
glb_lb_policy* glb_policy) { |
|
|
|
|
GPR_ASSERT(glb_policy->lb_call != NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->lb_call != nullptr); |
|
|
|
|
grpc_call_unref(glb_policy->lb_call); |
|
|
|
|
glb_policy->lb_call = NULL; |
|
|
|
|
glb_policy->lb_call = nullptr; |
|
|
|
|
|
|
|
|
|
grpc_metadata_array_destroy(&glb_policy->lb_initial_metadata_recv); |
|
|
|
|
grpc_metadata_array_destroy(&glb_policy->lb_trailing_metadata_recv); |
|
|
|
|
@ -1491,7 +1491,7 @@ static void lb_call_destroy_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
*/ |
|
|
|
|
static void query_for_backends_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
glb_lb_policy* glb_policy) { |
|
|
|
|
GPR_ASSERT(glb_policy->lb_channel != NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->lb_channel != nullptr); |
|
|
|
|
if (glb_policy->shutting_down) return; |
|
|
|
|
|
|
|
|
|
lb_call_init_locked(exec_ctx, glb_policy); |
|
|
|
|
@ -1501,7 +1501,7 @@ static void query_for_backends_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
"[grpclb %p] Query for backends (lb_channel: %p, lb_call: %p)", |
|
|
|
|
glb_policy, glb_policy->lb_channel, glb_policy->lb_call); |
|
|
|
|
} |
|
|
|
|
GPR_ASSERT(glb_policy->lb_call != NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->lb_call != nullptr); |
|
|
|
|
|
|
|
|
|
grpc_call_error call_error; |
|
|
|
|
grpc_op ops[3]; |
|
|
|
|
@ -1511,22 +1511,22 @@ static void query_for_backends_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
op->op = GRPC_OP_SEND_INITIAL_METADATA; |
|
|
|
|
op->data.send_initial_metadata.count = 0; |
|
|
|
|
op->flags = 0; |
|
|
|
|
op->reserved = NULL; |
|
|
|
|
op->reserved = nullptr; |
|
|
|
|
op++; |
|
|
|
|
op->op = GRPC_OP_RECV_INITIAL_METADATA; |
|
|
|
|
op->data.recv_initial_metadata.recv_initial_metadata = |
|
|
|
|
&glb_policy->lb_initial_metadata_recv; |
|
|
|
|
op->flags = 0; |
|
|
|
|
op->reserved = NULL; |
|
|
|
|
op->reserved = nullptr; |
|
|
|
|
op++; |
|
|
|
|
GPR_ASSERT(glb_policy->lb_request_payload != NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->lb_request_payload != nullptr); |
|
|
|
|
op->op = GRPC_OP_SEND_MESSAGE; |
|
|
|
|
op->data.send_message.send_message = glb_policy->lb_request_payload; |
|
|
|
|
op->flags = 0; |
|
|
|
|
op->reserved = NULL; |
|
|
|
|
op->reserved = nullptr; |
|
|
|
|
op++; |
|
|
|
|
call_error = grpc_call_start_batch_and_execute(exec_ctx, glb_policy->lb_call, |
|
|
|
|
ops, (size_t)(op - ops), NULL); |
|
|
|
|
call_error = grpc_call_start_batch_and_execute( |
|
|
|
|
exec_ctx, glb_policy->lb_call, ops, (size_t)(op - ops), nullptr); |
|
|
|
|
GPR_ASSERT(GRPC_CALL_OK == call_error); |
|
|
|
|
|
|
|
|
|
op = ops; |
|
|
|
|
@ -1537,7 +1537,7 @@ static void query_for_backends_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
op->data.recv_status_on_client.status_details = |
|
|
|
|
&glb_policy->lb_call_status_details; |
|
|
|
|
op->flags = 0; |
|
|
|
|
op->reserved = NULL; |
|
|
|
|
op->reserved = nullptr; |
|
|
|
|
op++; |
|
|
|
|
/* take a weak ref (won't prevent calling of \a glb_shutdown if the strong ref
|
|
|
|
|
* count goes to zero) to be unref'd in lb_on_server_status_received_locked */ |
|
|
|
|
@ -1552,7 +1552,7 @@ static void query_for_backends_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
op->op = GRPC_OP_RECV_MESSAGE; |
|
|
|
|
op->data.recv_message.recv_message = &glb_policy->lb_response_payload; |
|
|
|
|
op->flags = 0; |
|
|
|
|
op->reserved = NULL; |
|
|
|
|
op->reserved = nullptr; |
|
|
|
|
op++; |
|
|
|
|
/* take another weak ref to be unref'd/reused in
|
|
|
|
|
* lb_on_response_received_locked */ |
|
|
|
|
@ -1569,7 +1569,7 @@ static void lb_on_response_received_locked(grpc_exec_ctx* exec_ctx, void* arg, |
|
|
|
|
grpc_op ops[2]; |
|
|
|
|
memset(ops, 0, sizeof(ops)); |
|
|
|
|
grpc_op* op = ops; |
|
|
|
|
if (glb_policy->lb_response_payload != NULL) { |
|
|
|
|
if (glb_policy->lb_response_payload != nullptr) { |
|
|
|
|
grpc_backoff_reset(&glb_policy->lb_call_backoff_state); |
|
|
|
|
/* Received data from the LB server. Look inside
|
|
|
|
|
* glb_policy->lb_response_payload, for a serverlist. */ |
|
|
|
|
@ -1579,10 +1579,10 @@ static void lb_on_response_received_locked(grpc_exec_ctx* exec_ctx, void* arg, |
|
|
|
|
grpc_byte_buffer_reader_destroy(&bbr); |
|
|
|
|
grpc_byte_buffer_destroy(glb_policy->lb_response_payload); |
|
|
|
|
|
|
|
|
|
grpc_grpclb_initial_response* response = NULL; |
|
|
|
|
grpc_grpclb_initial_response* response = nullptr; |
|
|
|
|
if (!glb_policy->seen_initial_response && |
|
|
|
|
(response = grpc_grpclb_initial_response_parse(response_slice)) != |
|
|
|
|
NULL) { |
|
|
|
|
nullptr) { |
|
|
|
|
if (response->has_client_stats_report_interval) { |
|
|
|
|
glb_policy->client_stats_report_interval = GPR_MAX( |
|
|
|
|
GPR_MS_PER_SEC, grpc_grpclb_duration_to_millis( |
|
|
|
|
@ -1610,8 +1610,8 @@ static void lb_on_response_received_locked(grpc_exec_ctx* exec_ctx, void* arg, |
|
|
|
|
} else { |
|
|
|
|
grpc_grpclb_serverlist* serverlist = |
|
|
|
|
grpc_grpclb_response_parse_serverlist(response_slice); |
|
|
|
|
if (serverlist != NULL) { |
|
|
|
|
GPR_ASSERT(glb_policy->lb_call != NULL); |
|
|
|
|
if (serverlist != nullptr) { |
|
|
|
|
GPR_ASSERT(glb_policy->lb_call != nullptr); |
|
|
|
|
if (GRPC_TRACER_ON(grpc_lb_glb_trace)) { |
|
|
|
|
gpr_log(GPR_INFO, |
|
|
|
|
"[grpclb %p] Serverlist with %" PRIuPTR " servers received", |
|
|
|
|
@ -1638,14 +1638,14 @@ static void lb_on_response_received_locked(grpc_exec_ctx* exec_ctx, void* arg, |
|
|
|
|
} |
|
|
|
|
grpc_grpclb_destroy_serverlist(serverlist); |
|
|
|
|
} else { /* new serverlist */ |
|
|
|
|
if (glb_policy->serverlist != NULL) { |
|
|
|
|
if (glb_policy->serverlist != nullptr) { |
|
|
|
|
/* dispose of the old serverlist */ |
|
|
|
|
grpc_grpclb_destroy_serverlist(glb_policy->serverlist); |
|
|
|
|
} else { |
|
|
|
|
/* or dispose of the fallback */ |
|
|
|
|
grpc_lb_addresses_destroy(exec_ctx, |
|
|
|
|
glb_policy->fallback_backend_addresses); |
|
|
|
|
glb_policy->fallback_backend_addresses = NULL; |
|
|
|
|
glb_policy->fallback_backend_addresses = nullptr; |
|
|
|
|
if (glb_policy->fallback_timer_active) { |
|
|
|
|
grpc_timer_cancel(exec_ctx, &glb_policy->lb_fallback_timer); |
|
|
|
|
glb_policy->fallback_timer_active = false; |
|
|
|
|
@ -1679,7 +1679,7 @@ static void lb_on_response_received_locked(grpc_exec_ctx* exec_ctx, void* arg, |
|
|
|
|
op->op = GRPC_OP_RECV_MESSAGE; |
|
|
|
|
op->data.recv_message.recv_message = &glb_policy->lb_response_payload; |
|
|
|
|
op->flags = 0; |
|
|
|
|
op->reserved = NULL; |
|
|
|
|
op->reserved = nullptr; |
|
|
|
|
op++; |
|
|
|
|
/* reuse the "lb_on_response_received_locked" weak ref taken in
|
|
|
|
|
* query_for_backends_locked() */ |
|
|
|
|
@ -1705,14 +1705,14 @@ static void lb_on_fallback_timer_locked(grpc_exec_ctx* exec_ctx, void* arg, |
|
|
|
|
glb_policy->fallback_timer_active = false; |
|
|
|
|
/* If we receive a serverlist after the timer fires but before this callback
|
|
|
|
|
* actually runs, don't fall back. */ |
|
|
|
|
if (glb_policy->serverlist == NULL) { |
|
|
|
|
if (glb_policy->serverlist == nullptr) { |
|
|
|
|
if (!glb_policy->shutting_down && error == GRPC_ERROR_NONE) { |
|
|
|
|
if (GRPC_TRACER_ON(grpc_lb_glb_trace)) { |
|
|
|
|
gpr_log(GPR_INFO, |
|
|
|
|
"[grpclb %p] Falling back to use backends from resolver", |
|
|
|
|
glb_policy); |
|
|
|
|
} |
|
|
|
|
GPR_ASSERT(glb_policy->fallback_backend_addresses != NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->fallback_backend_addresses != nullptr); |
|
|
|
|
rr_handover_locked(exec_ctx, glb_policy); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
@ -1723,7 +1723,7 @@ static void lb_on_fallback_timer_locked(grpc_exec_ctx* exec_ctx, void* arg, |
|
|
|
|
static void lb_on_server_status_received_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
void* arg, grpc_error* error) { |
|
|
|
|
glb_lb_policy* glb_policy = (glb_lb_policy*)arg; |
|
|
|
|
GPR_ASSERT(glb_policy->lb_call != NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->lb_call != nullptr); |
|
|
|
|
if (GRPC_TRACER_ON(grpc_lb_glb_trace)) { |
|
|
|
|
char* status_details = |
|
|
|
|
grpc_slice_to_c_string(glb_policy->lb_call_status_details); |
|
|
|
|
@ -1747,7 +1747,7 @@ static void lb_on_server_status_received_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
static void fallback_update_locked(grpc_exec_ctx* exec_ctx, |
|
|
|
|
glb_lb_policy* glb_policy, |
|
|
|
|
const grpc_lb_addresses* addresses) { |
|
|
|
|
GPR_ASSERT(glb_policy->fallback_backend_addresses != NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->fallback_backend_addresses != nullptr); |
|
|
|
|
grpc_lb_addresses_destroy(exec_ctx, glb_policy->fallback_backend_addresses); |
|
|
|
|
glb_policy->fallback_backend_addresses = |
|
|
|
|
extract_backend_addresses_locked(exec_ctx, addresses); |
|
|
|
|
@ -1762,8 +1762,8 @@ static void glb_update_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy, |
|
|
|
|
glb_lb_policy* glb_policy = (glb_lb_policy*)policy; |
|
|
|
|
const grpc_arg* arg = |
|
|
|
|
grpc_channel_args_find(args->args, GRPC_ARG_LB_ADDRESSES); |
|
|
|
|
if (arg == NULL || arg->type != GRPC_ARG_POINTER) { |
|
|
|
|
if (glb_policy->lb_channel == NULL) { |
|
|
|
|
if (arg == nullptr || arg->type != GRPC_ARG_POINTER) { |
|
|
|
|
if (glb_policy->lb_channel == nullptr) { |
|
|
|
|
// If we don't have a current channel to the LB, go into TRANSIENT
|
|
|
|
|
// FAILURE.
|
|
|
|
|
grpc_connectivity_state_set( |
|
|
|
|
@ -1783,10 +1783,10 @@ static void glb_update_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy, |
|
|
|
|
(const grpc_lb_addresses*)arg->value.pointer.p; |
|
|
|
|
// If a non-empty serverlist hasn't been received from the balancer,
|
|
|
|
|
// propagate the update to fallback_backend_addresses.
|
|
|
|
|
if (glb_policy->serverlist == NULL) { |
|
|
|
|
if (glb_policy->serverlist == nullptr) { |
|
|
|
|
fallback_update_locked(exec_ctx, glb_policy, addresses); |
|
|
|
|
} |
|
|
|
|
GPR_ASSERT(glb_policy->lb_channel != NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->lb_channel != nullptr); |
|
|
|
|
// Propagate updates to the LB channel (pick_first) through the fake
|
|
|
|
|
// resolver.
|
|
|
|
|
grpc_channel_args* lb_channel_args = build_lb_channel_args( |
|
|
|
|
@ -1809,7 +1809,7 @@ static void glb_update_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy, |
|
|
|
|
grpc_polling_entity_create_from_pollset_set( |
|
|
|
|
glb_policy->base.interested_parties), |
|
|
|
|
&glb_policy->lb_channel_connectivity, |
|
|
|
|
&glb_policy->lb_channel_on_connectivity_changed, NULL); |
|
|
|
|
&glb_policy->lb_channel_on_connectivity_changed, nullptr); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -1837,7 +1837,7 @@ static void glb_lb_channel_on_connectivity_changed_cb(grpc_exec_ctx* exec_ctx, |
|
|
|
|
grpc_polling_entity_create_from_pollset_set( |
|
|
|
|
glb_policy->base.interested_parties), |
|
|
|
|
&glb_policy->lb_channel_connectivity, |
|
|
|
|
&glb_policy->lb_channel_on_connectivity_changed, NULL); |
|
|
|
|
&glb_policy->lb_channel_on_connectivity_changed, nullptr); |
|
|
|
|
break; |
|
|
|
|
} |
|
|
|
|
case GRPC_CHANNEL_IDLE: |
|
|
|
|
@ -1845,9 +1845,9 @@ static void glb_lb_channel_on_connectivity_changed_cb(grpc_exec_ctx* exec_ctx, |
|
|
|
|
// call to kick the lb channel into gear.
|
|
|
|
|
/* fallthrough */ |
|
|
|
|
case GRPC_CHANNEL_READY: |
|
|
|
|
if (glb_policy->lb_call != NULL) { |
|
|
|
|
if (glb_policy->lb_call != nullptr) { |
|
|
|
|
glb_policy->updating_lb_call = true; |
|
|
|
|
grpc_call_cancel(glb_policy->lb_call, NULL); |
|
|
|
|
grpc_call_cancel(glb_policy->lb_call, nullptr); |
|
|
|
|
// lb_on_server_status_received() will pick up the cancel and reinit
|
|
|
|
|
// lb_call.
|
|
|
|
|
} else if (glb_policy->started_picking && !glb_policy->shutting_down) { |
|
|
|
|
@ -1886,21 +1886,21 @@ static grpc_lb_policy* glb_create(grpc_exec_ctx* exec_ctx, |
|
|
|
|
/* Count the number of gRPC-LB addresses. There must be at least one. */ |
|
|
|
|
const grpc_arg* arg = |
|
|
|
|
grpc_channel_args_find(args->args, GRPC_ARG_LB_ADDRESSES); |
|
|
|
|
if (arg == NULL || arg->type != GRPC_ARG_POINTER) { |
|
|
|
|
return NULL; |
|
|
|
|
if (arg == nullptr || arg->type != GRPC_ARG_POINTER) { |
|
|
|
|
return nullptr; |
|
|
|
|
} |
|
|
|
|
grpc_lb_addresses* addresses = (grpc_lb_addresses*)arg->value.pointer.p; |
|
|
|
|
size_t num_grpclb_addrs = 0; |
|
|
|
|
for (size_t i = 0; i < addresses->num_addresses; ++i) { |
|
|
|
|
if (addresses->addresses[i].is_balancer) ++num_grpclb_addrs; |
|
|
|
|
} |
|
|
|
|
if (num_grpclb_addrs == 0) return NULL; |
|
|
|
|
if (num_grpclb_addrs == 0) return nullptr; |
|
|
|
|
|
|
|
|
|
glb_lb_policy* glb_policy = (glb_lb_policy*)gpr_zalloc(sizeof(*glb_policy)); |
|
|
|
|
|
|
|
|
|
/* Get server name. */ |
|
|
|
|
arg = grpc_channel_args_find(args->args, GRPC_ARG_SERVER_URI); |
|
|
|
|
GPR_ASSERT(arg != NULL); |
|
|
|
|
GPR_ASSERT(arg != nullptr); |
|
|
|
|
GPR_ASSERT(arg->type == GRPC_ARG_STRING); |
|
|
|
|
grpc_uri* uri = grpc_uri_parse(exec_ctx, arg->value.string, true); |
|
|
|
|
GPR_ASSERT(uri->path[0] != '\0'); |
|
|
|
|
@ -1914,7 +1914,7 @@ static grpc_lb_policy* glb_create(grpc_exec_ctx* exec_ctx, |
|
|
|
|
grpc_uri_destroy(uri); |
|
|
|
|
|
|
|
|
|
glb_policy->cc_factory = args->client_channel_factory; |
|
|
|
|
GPR_ASSERT(glb_policy->cc_factory != NULL); |
|
|
|
|
GPR_ASSERT(glb_policy->cc_factory != nullptr); |
|
|
|
|
|
|
|
|
|
arg = grpc_channel_args_find(args->args, GRPC_ARG_GRPCLB_CALL_TIMEOUT_MS); |
|
|
|
|
glb_policy->lb_call_timeout_ms = |
|
|
|
|
@ -1952,11 +1952,11 @@ static grpc_lb_policy* glb_create(grpc_exec_ctx* exec_ctx, |
|
|
|
|
exec_ctx, glb_policy->response_generator, lb_channel_args); |
|
|
|
|
grpc_channel_args_destroy(exec_ctx, lb_channel_args); |
|
|
|
|
gpr_free(uri_str); |
|
|
|
|
if (glb_policy->lb_channel == NULL) { |
|
|
|
|
if (glb_policy->lb_channel == nullptr) { |
|
|
|
|
gpr_free((void*)glb_policy->server_name); |
|
|
|
|
grpc_channel_args_destroy(exec_ctx, glb_policy->args); |
|
|
|
|
gpr_free(glb_policy); |
|
|
|
|
return NULL; |
|
|
|
|
return nullptr; |
|
|
|
|
} |
|
|
|
|
grpc_subchannel_index_ref(); |
|
|
|
|
GRPC_CLOSURE_INIT(&glb_policy->lb_channel_on_connectivity_changed, |
|
|
|
|
@ -1990,10 +1990,10 @@ static bool maybe_add_client_load_reporting_filter( |
|
|
|
|
grpc_channel_stack_builder_get_channel_arguments(builder); |
|
|
|
|
const grpc_arg* channel_arg = |
|
|
|
|
grpc_channel_args_find(args, GRPC_ARG_LB_POLICY_NAME); |
|
|
|
|
if (channel_arg != NULL && channel_arg->type == GRPC_ARG_STRING && |
|
|
|
|
if (channel_arg != nullptr && channel_arg->type == GRPC_ARG_STRING && |
|
|
|
|
strcmp(channel_arg->value.string, "grpclb") == 0) { |
|
|
|
|
return grpc_channel_stack_builder_append_filter( |
|
|
|
|
builder, (const grpc_channel_filter*)arg, NULL, NULL); |
|
|
|
|
builder, (const grpc_channel_filter*)arg, nullptr, nullptr); |
|
|
|
|
} |
|
|
|
|
return true; |
|
|
|
|
} |
|
|
|
|
|
Craig Tiller
7 years ago
committed by
GitHub