| /* |
| * |
| * Copyright 2017 gRPC authors. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| #include <grpc/support/port_platform.h> |
| |
| #include "src/core/ext/filters/max_age/max_age_filter.h" |
| |
| #include <limits.h> |
| #include <string.h> |
| |
| #include "src/core/lib/channel/channel_args.h" |
| #include "src/core/lib/channel/channel_stack_builder.h" |
| #include "src/core/lib/iomgr/timer.h" |
| #include "src/core/lib/surface/channel_init.h" |
| #include "src/core/lib/transport/http2_errors.h" |
| |
| /* If these settings change, make sure that we are not sending a GOAWAY for |
| * inproc transport, since a GOAWAY to inproc ends up destroying the transport. |
| */ |
| #define DEFAULT_MAX_CONNECTION_AGE_MS INT_MAX |
| #define DEFAULT_MAX_CONNECTION_AGE_GRACE_MS INT_MAX |
| #define DEFAULT_MAX_CONNECTION_IDLE_MS INT_MAX |
| #define MAX_CONNECTION_AGE_JITTER 0.1 |
| |
| #define MAX_CONNECTION_AGE_INTEGER_OPTIONS \ |
| { DEFAULT_MAX_CONNECTION_AGE_MS, 1, INT_MAX } |
| #define MAX_CONNECTION_IDLE_INTEGER_OPTIONS \ |
| { DEFAULT_MAX_CONNECTION_IDLE_MS, 1, INT_MAX } |
| |
| /* States for idle_state in channel_data */ |
| #define MAX_IDLE_STATE_INIT ((gpr_atm)0) |
| #define MAX_IDLE_STATE_SEEN_EXIT_IDLE ((gpr_atm)1) |
| #define MAX_IDLE_STATE_SEEN_ENTER_IDLE ((gpr_atm)2) |
| #define MAX_IDLE_STATE_TIMER_SET ((gpr_atm)3) |
| |
| namespace { |
| struct channel_data { |
| /* The channel stack to which we take refs for pending callbacks. */ |
| grpc_channel_stack* channel_stack; |
| /* Guards access to max_age_timer, max_age_timer_pending, max_age_grace_timer |
| and max_age_grace_timer_pending */ |
| gpr_mu max_age_timer_mu; |
| /* True if the max_age timer callback is currently pending */ |
| bool max_age_timer_pending; |
| /* True if the max_age_grace timer callback is currently pending */ |
| bool max_age_grace_timer_pending; |
| /* The timer for checking if the channel has reached its max age */ |
| grpc_timer max_age_timer; |
| /* The timer for checking if the max-aged channel has uesed up the grace |
| period */ |
| grpc_timer max_age_grace_timer; |
| /* The timer for checking if the channel's idle duration reaches |
| max_connection_idle */ |
| grpc_timer max_idle_timer; |
| /* Allowed max time a channel may have no outstanding rpcs */ |
| grpc_millis max_connection_idle; |
| /* Allowed max time a channel may exist */ |
| grpc_millis max_connection_age; |
| /* Allowed grace period after the channel reaches its max age */ |
| grpc_millis max_connection_age_grace; |
| /* Closure to run when the channel's idle duration reaches max_connection_idle |
| and should be closed gracefully */ |
| grpc_closure max_idle_timer_cb; |
| /* Closure to run when the channel reaches its max age and should be closed |
| gracefully */ |
| grpc_closure close_max_age_channel; |
| /* Closure to run the channel uses up its max age grace time and should be |
| closed forcibly */ |
| grpc_closure force_close_max_age_channel; |
| /* Closure to run when the init fo channel stack is done and the max_idle |
| timer should be started */ |
| grpc_closure start_max_idle_timer_after_init; |
| /* Closure to run when the init fo channel stack is done and the max_age timer |
| should be started */ |
| grpc_closure start_max_age_timer_after_init; |
| /* Closure to run when the goaway op is finished and the max_age_timer */ |
| grpc_closure start_max_age_grace_timer_after_goaway_op; |
| /* Number of active calls */ |
| gpr_atm call_count; |
| /* TODO(zyc): C++lize this state machine */ |
| /* 'idle_state' holds the states of max_idle_timer and channel idleness. |
| It can contain one of the following values: |
| +--------------------------------+----------------+---------+ |
| | idle_state | max_idle_timer | channel | |
| +--------------------------------+----------------+---------+ |
| | MAX_IDLE_STATE_INIT | unset | busy | |
| | MAX_IDLE_STATE_TIMER_SET | set, valid | idle | |
| | MAX_IDLE_STATE_SEEN_EXIT_IDLE | set, invalid | busy | |
| | MAX_IDLE_STATE_SEEN_ENTER_IDLE | set, invalid | idle | |
| +--------------------------------+----------------+---------+ |
| |
| MAX_IDLE_STATE_INIT: The initial and final state of 'idle_state'. The |
| channel has 1 or 1+ active calls, and the timer is not set. Note that |
| we may put a virtual call to hold this state at channel initialization or |
| shutdown, so that the channel won't enter other states. |
| |
| MAX_IDLE_STATE_TIMER_SET: The state after the timer is set and no calls |
| have arrived after the timer is set. The channel must have 0 active call in |
| this state. If the timer is fired in this state, we will close the channel |
| due to idleness. |
| |
| MAX_IDLE_STATE_SEEN_EXIT_IDLE: The state after the timer is set and at |
| least one call has arrived after the timer is set. The channel must have 1 |
| or 1+ active calls in this state. If the timer is fired in this state, we |
| won't reschudle it. |
| |
| MAX_IDLE_STATE_SEEN_ENTER_IDLE: The state after the timer is set and the at |
| least one call has arrived after the timer is set, BUT the channel |
| currently has 0 active calls. If the timer is fired in this state, we will |
| reschudle it. |
| |
| max_idle_timer will not be cancelled (unless the channel is shutting down). |
| If the timer callback is called when the max_idle_timer is valid (i.e. |
| idle_state is MAX_IDLE_STATE_TIMER_SET), the channel will be closed due to |
| idleness, otherwise the channel won't be changed. |
| |
| State transitions: |
| MAX_IDLE_STATE_INIT <-------3------ MAX_IDLE_STATE_SEEN_EXIT_IDLE |
| ^ | ^ ^ | |
| | | | | | |
| 1 2 +-----------4------------+ 6 7 |
| | | | | | |
| | v | | v |
| MAX_IDLE_STATE_TIMER_SET <----5------ MAX_IDLE_STATE_SEEN_ENTER_IDLE |
| |
| For 1, 3, 5 : See max_idle_timer_cb() function |
| For 2, 7 : See decrease_call_count() function |
| For 4, 6 : See increase_call_count() function */ |
| gpr_atm idle_state; |
| /* Time when the channel finished its last outstanding call, in grpc_millis */ |
| gpr_atm last_enter_idle_time_millis; |
| }; |
| } // namespace |
| |
| /* Increase the nubmer of active calls. Before the increasement, if there are no |
| calls, the max_idle_timer should be cancelled. */ |
| static void increase_call_count(channel_data* chand) { |
| /* Exit idle */ |
| if (gpr_atm_full_fetch_add(&chand->call_count, 1) == 0) { |
| while (true) { |
| gpr_atm idle_state = gpr_atm_acq_load(&chand->idle_state); |
| switch (idle_state) { |
| case MAX_IDLE_STATE_TIMER_SET: |
| /* max_idle_timer_cb may have already set idle_state to |
| MAX_IDLE_STATE_INIT, in this case, we don't need to set it to |
| MAX_IDLE_STATE_SEEN_EXIT_IDLE */ |
| gpr_atm_rel_cas(&chand->idle_state, MAX_IDLE_STATE_TIMER_SET, |
| MAX_IDLE_STATE_SEEN_EXIT_IDLE); |
| return; |
| case MAX_IDLE_STATE_SEEN_ENTER_IDLE: |
| gpr_atm_rel_store(&chand->idle_state, MAX_IDLE_STATE_SEEN_EXIT_IDLE); |
| return; |
| default: |
| /* try again */ |
| break; |
| } |
| } |
| } |
| } |
| |
| /* Decrease the nubmer of active calls. After the decrement, if there are no |
| calls, the max_idle_timer should be started. */ |
| static void decrease_call_count(channel_data* chand) { |
| /* Enter idle */ |
| if (gpr_atm_full_fetch_add(&chand->call_count, -1) == 1) { |
| gpr_atm_no_barrier_store(&chand->last_enter_idle_time_millis, |
| (gpr_atm)grpc_core::ExecCtx::Get()->Now()); |
| while (true) { |
| gpr_atm idle_state = gpr_atm_acq_load(&chand->idle_state); |
| switch (idle_state) { |
| case MAX_IDLE_STATE_INIT: |
| GRPC_CHANNEL_STACK_REF(chand->channel_stack, |
| "max_age max_idle_timer"); |
| grpc_timer_init( |
| &chand->max_idle_timer, |
| grpc_core::ExecCtx::Get()->Now() + chand->max_connection_idle, |
| &chand->max_idle_timer_cb); |
| gpr_atm_rel_store(&chand->idle_state, MAX_IDLE_STATE_TIMER_SET); |
| return; |
| case MAX_IDLE_STATE_SEEN_EXIT_IDLE: |
| if (gpr_atm_rel_cas(&chand->idle_state, MAX_IDLE_STATE_SEEN_EXIT_IDLE, |
| MAX_IDLE_STATE_SEEN_ENTER_IDLE)) { |
| return; |
| } |
| break; |
| default: |
| /* try again */ |
| break; |
| } |
| } |
| } |
| } |
| |
| static void start_max_idle_timer_after_init(void* arg, grpc_error* /*error*/) { |
| channel_data* chand = static_cast<channel_data*>(arg); |
| /* Decrease call_count. If there are no active calls at this time, |
| max_idle_timer will start here. If the number of active calls is not 0, |
| max_idle_timer will start after all the active calls end. */ |
| decrease_call_count(chand); |
| GRPC_CHANNEL_STACK_UNREF(chand->channel_stack, |
| "max_age start_max_idle_timer_after_init"); |
| } |
| |
| namespace grpc_core { |
| |
| class ConnectivityWatcher : public AsyncConnectivityStateWatcherInterface { |
| public: |
| explicit ConnectivityWatcher(channel_data* chand) : chand_(chand) { |
| GRPC_CHANNEL_STACK_REF(chand_->channel_stack, "max_age conn_watch"); |
| } |
| |
| ~ConnectivityWatcher() { |
| GRPC_CHANNEL_STACK_UNREF(chand_->channel_stack, "max_age conn_watch"); |
| } |
| |
| private: |
| void OnConnectivityStateChange(grpc_connectivity_state new_state, |
| const absl::Status& /* status */) override { |
| if (new_state != GRPC_CHANNEL_SHUTDOWN) return; |
| { |
| MutexLock lock(&chand_->max_age_timer_mu); |
| if (chand_->max_age_timer_pending) { |
| grpc_timer_cancel(&chand_->max_age_timer); |
| chand_->max_age_timer_pending = false; |
| } |
| if (chand_->max_age_grace_timer_pending) { |
| grpc_timer_cancel(&chand_->max_age_grace_timer); |
| chand_->max_age_grace_timer_pending = false; |
| } |
| } |
| /* If there are no active calls, this increasement will cancel |
| max_idle_timer, and prevent max_idle_timer from being started in the |
| future. */ |
| increase_call_count(chand_); |
| if (gpr_atm_acq_load(&chand_->idle_state) == |
| MAX_IDLE_STATE_SEEN_EXIT_IDLE) { |
| grpc_timer_cancel(&chand_->max_idle_timer); |
| } |
| } |
| |
| channel_data* chand_; |
| }; |
| |
| } // namespace grpc_core |
| |
| static void start_max_age_timer_after_init(void* arg, grpc_error* /*error*/) { |
| channel_data* chand = static_cast<channel_data*>(arg); |
| gpr_mu_lock(&chand->max_age_timer_mu); |
| chand->max_age_timer_pending = true; |
| GRPC_CHANNEL_STACK_REF(chand->channel_stack, "max_age max_age_timer"); |
| grpc_timer_init(&chand->max_age_timer, |
| grpc_core::ExecCtx::Get()->Now() + chand->max_connection_age, |
| &chand->close_max_age_channel); |
| gpr_mu_unlock(&chand->max_age_timer_mu); |
| grpc_transport_op* op = grpc_make_transport_op(nullptr); |
| op->start_connectivity_watch.reset(new grpc_core::ConnectivityWatcher(chand)); |
| op->start_connectivity_watch_state = GRPC_CHANNEL_IDLE; |
| grpc_channel_next_op(grpc_channel_stack_element(chand->channel_stack, 0), op); |
| GRPC_CHANNEL_STACK_UNREF(chand->channel_stack, |
| "max_age start_max_age_timer_after_init"); |
| } |
| |
| static void start_max_age_grace_timer_after_goaway_op(void* arg, |
| grpc_error* /*error*/) { |
| channel_data* chand = static_cast<channel_data*>(arg); |
| gpr_mu_lock(&chand->max_age_timer_mu); |
| chand->max_age_grace_timer_pending = true; |
| GRPC_CHANNEL_STACK_REF(chand->channel_stack, "max_age max_age_grace_timer"); |
| grpc_timer_init( |
| &chand->max_age_grace_timer, |
| chand->max_connection_age_grace == GRPC_MILLIS_INF_FUTURE |
| ? GRPC_MILLIS_INF_FUTURE |
| : grpc_core::ExecCtx::Get()->Now() + chand->max_connection_age_grace, |
| &chand->force_close_max_age_channel); |
| gpr_mu_unlock(&chand->max_age_timer_mu); |
| GRPC_CHANNEL_STACK_UNREF(chand->channel_stack, |
| "max_age start_max_age_grace_timer_after_goaway_op"); |
| } |
| |
| static void close_max_idle_channel(channel_data* chand) { |
| /* Prevent the max idle timer from being set again */ |
| gpr_atm_no_barrier_fetch_add(&chand->call_count, 1); |
| grpc_transport_op* op = grpc_make_transport_op(nullptr); |
| op->goaway_error = |
| grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING("max_idle"), |
| GRPC_ERROR_INT_HTTP2_ERROR, GRPC_HTTP2_NO_ERROR); |
| grpc_channel_element* elem = |
| grpc_channel_stack_element(chand->channel_stack, 0); |
| elem->filter->start_transport_op(elem, op); |
| } |
| |
| static void max_idle_timer_cb(void* arg, grpc_error* error) { |
| channel_data* chand = static_cast<channel_data*>(arg); |
| if (error == GRPC_ERROR_NONE) { |
| bool try_again = true; |
| while (try_again) { |
| gpr_atm idle_state = gpr_atm_acq_load(&chand->idle_state); |
| switch (idle_state) { |
| case MAX_IDLE_STATE_TIMER_SET: |
| close_max_idle_channel(chand); |
| /* This MAX_IDLE_STATE_INIT is a final state, we don't have to check |
| * if idle_state has been changed */ |
| gpr_atm_rel_store(&chand->idle_state, MAX_IDLE_STATE_INIT); |
| try_again = false; |
| break; |
| case MAX_IDLE_STATE_SEEN_EXIT_IDLE: |
| if (gpr_atm_rel_cas(&chand->idle_state, MAX_IDLE_STATE_SEEN_EXIT_IDLE, |
| MAX_IDLE_STATE_INIT)) { |
| try_again = false; |
| } |
| break; |
| case MAX_IDLE_STATE_SEEN_ENTER_IDLE: |
| GRPC_CHANNEL_STACK_REF(chand->channel_stack, |
| "max_age max_idle_timer"); |
| grpc_timer_init(&chand->max_idle_timer, |
| static_cast<grpc_millis>(gpr_atm_no_barrier_load( |
| &chand->last_enter_idle_time_millis)) + |
| chand->max_connection_idle, |
| &chand->max_idle_timer_cb); |
| /* idle_state may have already been set to |
| MAX_IDLE_STATE_SEEN_EXIT_IDLE by increase_call_count(), in this |
| case, we don't need to set it to MAX_IDLE_STATE_TIMER_SET */ |
| gpr_atm_rel_cas(&chand->idle_state, MAX_IDLE_STATE_SEEN_ENTER_IDLE, |
| MAX_IDLE_STATE_TIMER_SET); |
| try_again = false; |
| break; |
| default: |
| /* try again */ |
| break; |
| } |
| } |
| } |
| GRPC_CHANNEL_STACK_UNREF(chand->channel_stack, "max_age max_idle_timer"); |
| } |
| |
| static void close_max_age_channel(void* arg, grpc_error* error) { |
| channel_data* chand = static_cast<channel_data*>(arg); |
| gpr_mu_lock(&chand->max_age_timer_mu); |
| chand->max_age_timer_pending = false; |
| gpr_mu_unlock(&chand->max_age_timer_mu); |
| if (error == GRPC_ERROR_NONE) { |
| GRPC_CHANNEL_STACK_REF(chand->channel_stack, |
| "max_age start_max_age_grace_timer_after_goaway_op"); |
| grpc_transport_op* op = grpc_make_transport_op( |
| &chand->start_max_age_grace_timer_after_goaway_op); |
| op->goaway_error = |
| grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING("max_age"), |
| GRPC_ERROR_INT_HTTP2_ERROR, GRPC_HTTP2_NO_ERROR); |
| grpc_channel_element* elem = |
| grpc_channel_stack_element(chand->channel_stack, 0); |
| elem->filter->start_transport_op(elem, op); |
| } else if (error != GRPC_ERROR_CANCELLED) { |
| GRPC_LOG_IF_ERROR("close_max_age_channel", error); |
| } |
| GRPC_CHANNEL_STACK_UNREF(chand->channel_stack, "max_age max_age_timer"); |
| } |
| |
| static void force_close_max_age_channel(void* arg, grpc_error* error) { |
| channel_data* chand = static_cast<channel_data*>(arg); |
| gpr_mu_lock(&chand->max_age_timer_mu); |
| chand->max_age_grace_timer_pending = false; |
| gpr_mu_unlock(&chand->max_age_timer_mu); |
| if (error == GRPC_ERROR_NONE) { |
| grpc_transport_op* op = grpc_make_transport_op(nullptr); |
| op->disconnect_with_error = |
| GRPC_ERROR_CREATE_FROM_STATIC_STRING("Channel reaches max age"); |
| grpc_channel_element* elem = |
| grpc_channel_stack_element(chand->channel_stack, 0); |
| elem->filter->start_transport_op(elem, op); |
| } else if (error != GRPC_ERROR_CANCELLED) { |
| GRPC_LOG_IF_ERROR("force_close_max_age_channel", error); |
| } |
| GRPC_CHANNEL_STACK_UNREF(chand->channel_stack, "max_age max_age_grace_timer"); |
| } |
| |
| /* A random jitter of +/-10% will be added to MAX_CONNECTION_AGE to spread out |
| connection storms. Note that the MAX_CONNECTION_AGE option without jitter |
| would not create connection storms by itself, but if there happened to be a |
| connection storm it could cause it to repeat at a fixed period. */ |
| static grpc_millis |
| add_random_max_connection_age_jitter_and_convert_to_grpc_millis(int value) { |
| /* generate a random number between 1 - MAX_CONNECTION_AGE_JITTER and |
| 1 + MAX_CONNECTION_AGE_JITTER */ |
| double multiplier = rand() * MAX_CONNECTION_AGE_JITTER * 2.0 / RAND_MAX + |
| 1.0 - MAX_CONNECTION_AGE_JITTER; |
| double result = multiplier * value; |
| /* INT_MAX - 0.5 converts the value to float, so that result will not be |
| cast to int implicitly before the comparison. */ |
| return result > (static_cast<double>(GRPC_MILLIS_INF_FUTURE)) - 0.5 |
| ? GRPC_MILLIS_INF_FUTURE |
| : static_cast<grpc_millis>(result); |
| } |
| |
| /* Constructor for call_data. */ |
| static grpc_error* max_age_init_call_elem( |
| grpc_call_element* elem, const grpc_call_element_args* /*args*/) { |
| channel_data* chand = static_cast<channel_data*>(elem->channel_data); |
| increase_call_count(chand); |
| return GRPC_ERROR_NONE; |
| } |
| |
| /* Destructor for call_data. */ |
| static void max_age_destroy_call_elem( |
| grpc_call_element* elem, const grpc_call_final_info* /*final_info*/, |
| grpc_closure* /*ignored*/) { |
| channel_data* chand = static_cast<channel_data*>(elem->channel_data); |
| decrease_call_count(chand); |
| } |
| |
| /* Constructor for channel_data. */ |
| static grpc_error* max_age_init_channel_elem(grpc_channel_element* elem, |
| grpc_channel_element_args* args) { |
| channel_data* chand = static_cast<channel_data*>(elem->channel_data); |
| gpr_mu_init(&chand->max_age_timer_mu); |
| chand->max_age_timer_pending = false; |
| chand->max_age_grace_timer_pending = false; |
| chand->channel_stack = args->channel_stack; |
| chand->max_connection_age = |
| add_random_max_connection_age_jitter_and_convert_to_grpc_millis( |
| DEFAULT_MAX_CONNECTION_AGE_MS); |
| chand->max_connection_age_grace = |
| DEFAULT_MAX_CONNECTION_AGE_GRACE_MS == INT_MAX |
| ? GRPC_MILLIS_INF_FUTURE |
| : DEFAULT_MAX_CONNECTION_AGE_GRACE_MS; |
| chand->max_connection_idle = DEFAULT_MAX_CONNECTION_IDLE_MS == INT_MAX |
| ? GRPC_MILLIS_INF_FUTURE |
| : DEFAULT_MAX_CONNECTION_IDLE_MS; |
| chand->idle_state = MAX_IDLE_STATE_INIT; |
| gpr_atm_no_barrier_store(&chand->last_enter_idle_time_millis, GPR_ATM_MIN); |
| for (size_t i = 0; i < args->channel_args->num_args; ++i) { |
| if (0 == strcmp(args->channel_args->args[i].key, |
| GRPC_ARG_MAX_CONNECTION_AGE_MS)) { |
| const int value = grpc_channel_arg_get_integer( |
| &args->channel_args->args[i], MAX_CONNECTION_AGE_INTEGER_OPTIONS); |
| chand->max_connection_age = |
| add_random_max_connection_age_jitter_and_convert_to_grpc_millis( |
| value); |
| } else if (0 == strcmp(args->channel_args->args[i].key, |
| GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS)) { |
| const int value = grpc_channel_arg_get_integer( |
| &args->channel_args->args[i], |
| {DEFAULT_MAX_CONNECTION_AGE_GRACE_MS, 0, INT_MAX}); |
| chand->max_connection_age_grace = |
| value == INT_MAX ? GRPC_MILLIS_INF_FUTURE : value; |
| } else if (0 == strcmp(args->channel_args->args[i].key, |
| GRPC_ARG_MAX_CONNECTION_IDLE_MS)) { |
| const int value = grpc_channel_arg_get_integer( |
| &args->channel_args->args[i], MAX_CONNECTION_IDLE_INTEGER_OPTIONS); |
| chand->max_connection_idle = |
| value == INT_MAX ? GRPC_MILLIS_INF_FUTURE : value; |
| } |
| } |
| GRPC_CLOSURE_INIT(&chand->max_idle_timer_cb, max_idle_timer_cb, chand, |
| grpc_schedule_on_exec_ctx); |
| GRPC_CLOSURE_INIT(&chand->close_max_age_channel, close_max_age_channel, chand, |
| grpc_schedule_on_exec_ctx); |
| GRPC_CLOSURE_INIT(&chand->force_close_max_age_channel, |
| force_close_max_age_channel, chand, |
| grpc_schedule_on_exec_ctx); |
| GRPC_CLOSURE_INIT(&chand->start_max_idle_timer_after_init, |
| start_max_idle_timer_after_init, chand, |
| grpc_schedule_on_exec_ctx); |
| GRPC_CLOSURE_INIT(&chand->start_max_age_timer_after_init, |
| start_max_age_timer_after_init, chand, |
| grpc_schedule_on_exec_ctx); |
| GRPC_CLOSURE_INIT(&chand->start_max_age_grace_timer_after_goaway_op, |
| start_max_age_grace_timer_after_goaway_op, chand, |
| grpc_schedule_on_exec_ctx); |
| |
| if (chand->max_connection_age != GRPC_MILLIS_INF_FUTURE) { |
| /* When the channel reaches its max age, we send down an op with |
| goaway_error set. However, we can't send down any ops until after the |
| channel stack is fully initialized. If we start the timer here, we have |
| no guarantee that the timer won't pop before channel stack initialization |
| is finished. To avoid that problem, we create a closure to start the |
| timer, and we schedule that closure to be run after call stack |
| initialization is done. */ |
| GRPC_CHANNEL_STACK_REF(chand->channel_stack, |
| "max_age start_max_age_timer_after_init"); |
| grpc_core::ExecCtx::Run(DEBUG_LOCATION, |
| &chand->start_max_age_timer_after_init, |
| GRPC_ERROR_NONE); |
| } |
| |
| /* Initialize the number of calls as 1, so that the max_idle_timer will not |
| start until start_max_idle_timer_after_init is invoked. */ |
| gpr_atm_rel_store(&chand->call_count, 1); |
| if (chand->max_connection_idle != GRPC_MILLIS_INF_FUTURE) { |
| GRPC_CHANNEL_STACK_REF(chand->channel_stack, |
| "max_age start_max_idle_timer_after_init"); |
| grpc_core::ExecCtx::Run(DEBUG_LOCATION, |
| &chand->start_max_idle_timer_after_init, |
| GRPC_ERROR_NONE); |
| } |
| return GRPC_ERROR_NONE; |
| } |
| |
| /* Destructor for channel_data. */ |
| static void max_age_destroy_channel_elem(grpc_channel_element* elem) { |
| channel_data* chand = static_cast<channel_data*>(elem->channel_data); |
| gpr_mu_destroy(&chand->max_age_timer_mu); |
| } |
| |
| const grpc_channel_filter grpc_max_age_filter = { |
| grpc_call_next_op, |
| grpc_channel_next_op, |
| 0, /* sizeof_call_data */ |
| max_age_init_call_elem, |
| grpc_call_stack_ignore_set_pollset_or_pollset_set, |
| max_age_destroy_call_elem, |
| sizeof(channel_data), |
| max_age_init_channel_elem, |
| max_age_destroy_channel_elem, |
| grpc_channel_next_get_info, |
| "max_age"}; |
| |
| static bool maybe_add_max_age_filter(grpc_channel_stack_builder* builder, |
| void* /*arg*/) { |
| const grpc_channel_args* channel_args = |
| grpc_channel_stack_builder_get_channel_arguments(builder); |
| bool enable = |
| grpc_channel_arg_get_integer( |
| grpc_channel_args_find(channel_args, GRPC_ARG_MAX_CONNECTION_AGE_MS), |
| MAX_CONNECTION_AGE_INTEGER_OPTIONS) != INT_MAX || |
| grpc_channel_arg_get_integer( |
| grpc_channel_args_find(channel_args, GRPC_ARG_MAX_CONNECTION_IDLE_MS), |
| MAX_CONNECTION_IDLE_INTEGER_OPTIONS) != INT_MAX; |
| if (enable) { |
| return grpc_channel_stack_builder_prepend_filter( |
| builder, &grpc_max_age_filter, nullptr, nullptr); |
| } else { |
| return true; |
| } |
| } |
| |
| void grpc_max_age_filter_init(void) { |
| grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL, |
| GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, |
| maybe_add_max_age_filter, nullptr); |
| } |
| |
| void grpc_max_age_filter_shutdown(void) {} |
