Chiebot-Mirror
/
grpc
mirror of https://github.com/grpc/grpc.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Change the unit to ms, clean up

Browse Source
pull/10318/head
Yuchen Zeng 8 years ago
parent 3835d13788
commit ca6dab39d6
4 changed files with 133 additions and 126 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 16
      include/grpc/impl/codegen/grpc_types.h
  2. 193
      src/core/lib/channel/max_age_filter.c
  3. 34
      test/core/end2end/tests/max_connection_age.c
  4. 16
      test/core/end2end/tests/max_connection_idle.c

16
include/grpc/impl/codegen/grpc_types.h
Unescape View File

@ -164,14 +164,14 @@ typedef struct {
-1 means unlimited. */
#define GRPC_ARG_MAX_SEND_MESSAGE_LENGTH "grpc.max_send_message_length"
/** Maximum time that a channel may have no outstanding rpcs. Int valued,
seconds. INT_MAX means unlimited. */
#define GRPC_ARG_MAX_CONNECTION_IDLE_S "grpc.max_connection_idle"
/** Maximum time that a channel may exist. Int valued, seconds. INT_MAX means
unlimited. */
#define GRPC_ARG_MAX_CONNECTION_AGE_S "grpc.max_connection_age"
/** Grace period after the chennel reaches its max age. Int valued, seconds.
INT_MAX means unlimited. */
#define GRPC_ARG_MAX_CONNECTION_AGE_GRACE_S "grpc.max_connection_age_grace"
milliseconds. INT_MAX means unlimited. */
#define GRPC_ARG_MAX_CONNECTION_IDLE_MS "grpc.max_connection_idle_ms"
/** Maximum time that a channel may exist. Int valued, milliseconds. INT_MAX
means unlimited. */
#define GRPC_ARG_MAX_CONNECTION_AGE_MS "grpc.max_connection_age_ms"
/** Grace period after the chennel reaches its max age. Int valued,
milliseconds. INT_MAX means unlimited. */
#define GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS "grpc.max_connection_age_grace_ms"
/** Initial sequence number for http2 transports. Int valued. */
#define GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER \
"grpc.http2.initial_sequence_number"

193
src/core/lib/channel/max_age_filter.c
Unescape View File

@ -1,104 +1,109 @@
//
// Copyright 2017, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
/*
*
* Copyright 2017, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include "src/core/lib/channel/message_size_filter.h"
#include <limits.h>
#include <string.h>
#include <grpc/support/log.h>
#include "src/core/lib/channel/channel_args.h"
#include "src/core/lib/iomgr/timer.h"
#include "src/core/lib/transport/http2_errors.h"
#include "src/core/lib/transport/service_config.h"
#define DEFAULT_MAX_CONNECTION_AGE_S INT_MAX
#define DEFAULT_MAX_CONNECTION_AGE_GRACE_S INT_MAX
#define DEFAULT_MAX_CONNECTION_IDLE_S INT_MAX
#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
typedef struct channel_data {
// We take a reference to the channel stack for the timer callback
/* We take a reference to the channel stack for the timer callback */
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
/* 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
/* 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
/* 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
/* 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
/* 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
/* 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
/* Allowed max time a channel may have no outstanding rpcs */
gpr_timespec max_connection_idle;
// Allowed max time a channel may exist
/* Allowed max time a channel may exist */
gpr_timespec max_connection_age;
// Allowed grace period after the channel reaches its max age
/* Allowed grace period after the channel reaches its max age */
gpr_timespec max_connection_age_grace;
// Closure to run when the channel's idle duration reaches max_connection_idle
// and should be closed gracefully
/* Closure to run when the channel's idle duration reaches max_connection_idle
and should be closed gracefully */
grpc_closure close_max_idle_channel;
// Closure to run when the channel reaches its max age and should be closed
// gracefully
/* 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
/* 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
/* 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
/* 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
/* Closure to run when the goaway op is finished and the max_age_timer */
grpc_closure start_max_age_grace_timer_after_goaway_op;
// Closure to run when the channel connectivity state changes
/* Closure to run when the channel connectivity state changes */
grpc_closure channel_connectivity_changed;
// Records the current connectivity state
/* Records the current connectivity state */
grpc_connectivity_state connectivity_state;
// Number of active calls
/* Number of active calls */
gpr_atm call_count;
} channel_data;
/* 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(grpc_exec_ctx* exec_ctx, channel_data* chand) {
if (gpr_atm_full_fetch_add(&chand->call_count, 1) == 0) {
grpc_timer_cancel(exec_ctx, &chand->max_idle_timer);
}
}
/* 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(grpc_exec_ctx* exec_ctx, channel_data* chand) {
if (gpr_atm_full_fetch_add(&chand->call_count, -1) == 1) {
GRPC_CHANNEL_STACK_REF(chand->channel_stack, "max_age max_idle_timer");
@ -112,6 +117,9 @@ static void decrease_call_count(grpc_exec_ctx* exec_ctx, channel_data* chand) {
static void start_max_idle_timer_after_init(grpc_exec_ctx* exec_ctx, void* arg,
grpc_error* error) {
channel_data* chand = 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(exec_ctx, chand);
GRPC_CHANNEL_STACK_UNREF(exec_ctx, chand->channel_stack,
"max_age start_max_idle_timer_after_init");
@ -180,7 +188,6 @@ static void close_max_age_channel(grpc_exec_ctx* exec_ctx, void* arg,
chand->max_age_timer_pending = false;
gpr_mu_unlock(&chand->max_age_timer_mu);
if (error == GRPC_ERROR_NONE) {
gpr_log(GPR_DEBUG, "close_max_age_channel");
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(
@ -205,7 +212,6 @@ static void force_close_max_age_channel(grpc_exec_ctx* exec_ctx, void* arg,
chand->max_age_grace_timer_pending = false;
gpr_mu_unlock(&chand->max_age_timer_mu);
if (error == GRPC_ERROR_NONE) {
gpr_log(GPR_DEBUG, "force_close_max_age_channel");
grpc_transport_op* op = grpc_make_transport_op(NULL);
op->disconnect_with_error =
GRPC_ERROR_CREATE_FROM_STATIC_STRING("Channel reaches max age");
@ -239,11 +245,14 @@ static void channel_connectivity_changed(grpc_exec_ctx* exec_ctx, void* arg,
chand->max_age_grace_timer_pending = false;
}
gpr_mu_unlock(&chand->max_age_timer_mu);
/* 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(exec_ctx, chand);
}
}
// Constructor for call_data.
/* Constructor for call_data. */
static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
grpc_call_element* elem,
const grpc_call_element_args* args) {
@ -252,7 +261,7 @@ static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
return GRPC_ERROR_NONE;
}
// Destructor for call_data.
/* Destructor for call_data. */
static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
const grpc_call_final_info* final_info,
grpc_closure* ignored) {
@ -260,7 +269,7 @@ static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
decrease_call_count(exec_ctx, chand);
}
// Constructor for channel_data.
/* Constructor for channel_data. */
static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
grpc_channel_element* elem,
grpc_channel_element_args* args) {
@ -270,44 +279,44 @@ static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
chand->max_age_grace_timer_pending = false;
chand->channel_stack = args->channel_stack;
chand->max_connection_age =
DEFAULT_MAX_CONNECTION_AGE_S == INT_MAX
DEFAULT_MAX_CONNECTION_AGE_MS == INT_MAX
? gpr_inf_future(GPR_TIMESPAN)
: gpr_time_from_seconds(DEFAULT_MAX_CONNECTION_AGE_S, GPR_TIMESPAN);
: gpr_time_from_millis(DEFAULT_MAX_CONNECTION_AGE_MS, GPR_TIMESPAN);
chand->max_connection_age_grace =
DEFAULT_MAX_CONNECTION_AGE_GRACE_S == INT_MAX
DEFAULT_MAX_CONNECTION_AGE_GRACE_MS == INT_MAX
? gpr_inf_future(GPR_TIMESPAN)
: gpr_time_from_seconds(DEFAULT_MAX_CONNECTION_AGE_GRACE_S,
GPR_TIMESPAN);
: gpr_time_from_millis(DEFAULT_MAX_CONNECTION_AGE_GRACE_MS,
GPR_TIMESPAN);
chand->max_connection_idle =
DEFAULT_MAX_CONNECTION_IDLE_S == INT_MAX
DEFAULT_MAX_CONNECTION_IDLE_MS == INT_MAX
? gpr_inf_future(GPR_TIMESPAN)
: gpr_time_from_seconds(DEFAULT_MAX_CONNECTION_IDLE_S, GPR_TIMESPAN);
: gpr_time_from_millis(DEFAULT_MAX_CONNECTION_IDLE_MS, GPR_TIMESPAN);
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_S)) {
GRPC_ARG_MAX_CONNECTION_AGE_MS)) {
const int value = grpc_channel_arg_get_integer(
&args->channel_args->args[i],
(grpc_integer_options){DEFAULT_MAX_CONNECTION_AGE_S, 1, INT_MAX});
(grpc_integer_options){DEFAULT_MAX_CONNECTION_AGE_MS, 1, INT_MAX});
chand->max_connection_age =
value == INT_MAX ? gpr_inf_future(GPR_TIMESPAN)
: gpr_time_from_seconds(value, GPR_TIMESPAN);
: gpr_time_from_millis(value, GPR_TIMESPAN);
} else if (0 == strcmp(args->channel_args->args[i].key,
GRPC_ARG_MAX_CONNECTION_AGE_GRACE_S)) {
GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS)) {
const int value = grpc_channel_arg_get_integer(
&args->channel_args->args[i],
(grpc_integer_options){DEFAULT_MAX_CONNECTION_AGE_GRACE_S, 0,
(grpc_integer_options){DEFAULT_MAX_CONNECTION_AGE_GRACE_MS, 0,
INT_MAX});
chand->max_connection_age_grace =
value == INT_MAX ? gpr_inf_future(GPR_TIMESPAN)
: gpr_time_from_seconds(value, GPR_TIMESPAN);
: gpr_time_from_millis(value, GPR_TIMESPAN);
} else if (0 == strcmp(args->channel_args->args[i].key,
GRPC_ARG_MAX_CONNECTION_IDLE_S)) {
GRPC_ARG_MAX_CONNECTION_IDLE_MS)) {
const int value = grpc_channel_arg_get_integer(
&args->channel_args->args[i],
(grpc_integer_options){DEFAULT_MAX_CONNECTION_IDLE_S, 1, INT_MAX});
(grpc_integer_options){DEFAULT_MAX_CONNECTION_IDLE_MS, 1, INT_MAX});
chand->max_connection_idle =
value == INT_MAX ? gpr_inf_future(GPR_TIMESPAN)
: gpr_time_from_seconds(value, GPR_TIMESPAN);
: gpr_time_from_millis(value, GPR_TIMESPAN);
}
}
grpc_closure_init(&chand->close_max_idle_channel, close_max_idle_channel,
@ -332,19 +341,21 @@ static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
if (gpr_time_cmp(chand->max_connection_age, gpr_inf_future(GPR_TIMESPAN)) !=
0) {
// 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.
/* 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_closure_sched(exec_ctx, &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 (gpr_time_cmp(chand->max_connection_idle, gpr_inf_future(GPR_TIMESPAN)) !=
0) {
@ -356,14 +367,14 @@ static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
return GRPC_ERROR_NONE;
}
// Destructor for channel_data.
/* Destructor for channel_data. */
static void destroy_channel_elem(grpc_exec_ctx* exec_ctx,
grpc_channel_element* elem) {}
const grpc_channel_filter grpc_max_age_filter = {
grpc_call_next_op,
grpc_channel_next_op,
0, // sizeof_call_data
0, /* sizeof_call_data */
init_call_elem,
grpc_call_stack_ignore_set_pollset_or_pollset_set,
destroy_call_elem,

34
test/core/end2end/tests/max_connection_age.c
Unescape View File

@ -36,18 +36,16 @@
#include <limits.h>
#include <string.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include <grpc/support/sync.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <grpc/support/useful.h>
#include "test/core/end2end/cq_verifier.h"
#define MAX_CONNECTION_AGE_S 1
#define MAX_CONNECTION_AGE_GRACE_S 2
#define MAX_CONNECTION_IDLE_S 99
#define MAX_CONNECTION_AGE_MS 500
#define MAX_CONNECTION_AGE_GRACE_MS 1000
#define MAX_CONNECTION_IDLE_MS 9999
static void *tag(intptr_t t) { return (void *)t; }
@ -84,14 +82,14 @@ static void test_max_age_forcibly_close(grpc_end2end_test_config config) {
grpc_end2end_test_fixture f = config.create_fixture(NULL, NULL);
cq_verifier *cqv = cq_verifier_create(f.cq);
grpc_arg server_a[] = {{.type = GRPC_ARG_INTEGER,
.key = GRPC_ARG_MAX_CONNECTION_AGE_S,
.value.integer = MAX_CONNECTION_AGE_S},
.key = GRPC_ARG_MAX_CONNECTION_AGE_MS,
.value.integer = MAX_CONNECTION_AGE_MS},
{.type = GRPC_ARG_INTEGER,
.key = GRPC_ARG_MAX_CONNECTION_AGE_GRACE_S,
.value.integer = MAX_CONNECTION_AGE_GRACE_S},
.key = GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS,
.value.integer = MAX_CONNECTION_AGE_GRACE_MS},
{.type = GRPC_ARG_INTEGER,
.key = GRPC_ARG_MAX_CONNECTION_IDLE_S,
.value.integer = MAX_CONNECTION_IDLE_S}};
.key = GRPC_ARG_MAX_CONNECTION_IDLE_MS,
.value.integer = MAX_CONNECTION_IDLE_MS}};
grpc_channel_args server_args = {.num_args = GPR_ARRAY_SIZE(server_a),
.args = server_a};
@ -159,7 +157,7 @@ static void test_max_age_forcibly_close(grpc_end2end_test_config config) {
cq_verify(cqv);
/* Wait for the channel to reach its max age */
cq_verify_empty_timeout(cqv, MAX_CONNECTION_AGE_S + 1);
cq_verify_empty_timeout(cqv, 1);
/* After the channel reaches its max age, we still do nothing here. And wait
for it to use up its max age grace period. */
@ -221,14 +219,14 @@ static void test_max_age_gracefully_close(grpc_end2end_test_config config) {
grpc_end2end_test_fixture f = config.create_fixture(NULL, NULL);
cq_verifier *cqv = cq_verifier_create(f.cq);
grpc_arg server_a[] = {{.type = GRPC_ARG_INTEGER,
.key = GRPC_ARG_MAX_CONNECTION_AGE_S,
.value.integer = MAX_CONNECTION_AGE_S},
.key = GRPC_ARG_MAX_CONNECTION_AGE_MS,
.value.integer = MAX_CONNECTION_AGE_MS},
{.type = GRPC_ARG_INTEGER,
.key = GRPC_ARG_MAX_CONNECTION_AGE_GRACE_S,
.key = GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS,
.value.integer = INT_MAX},
{.type = GRPC_ARG_INTEGER,
.key = GRPC_ARG_MAX_CONNECTION_IDLE_S,
.value.integer = MAX_CONNECTION_IDLE_S}};
.key = GRPC_ARG_MAX_CONNECTION_IDLE_MS,
.value.integer = MAX_CONNECTION_IDLE_MS}};
grpc_channel_args server_args = {.num_args = GPR_ARRAY_SIZE(server_a),
.args = server_a};
@ -296,7 +294,7 @@ static void test_max_age_gracefully_close(grpc_end2end_test_config config) {
cq_verify(cqv);
/* Wait for the channel to reach its max age */
cq_verify_empty_timeout(cqv, MAX_CONNECTION_AGE_S + 1);
cq_verify_empty_timeout(cqv, 1);
/* The connection is shutting down gracefully. In-progress rpc should not be
closed, hence the completion queue should see nothing here. */

16
test/core/end2end/tests/max_connection_idle.c
Unescape View File

@ -36,17 +36,15 @@
#include <limits.h>
#include <string.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include <grpc/support/sync.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <grpc/support/useful.h>
#include "test/core/end2end/cq_verifier.h"
#define MAX_CONNECTION_IDLE_S 1
#define MAX_CONNECTION_AGE_S 99
#define MAX_CONNECTION_IDLE_MS 500
#define MAX_CONNECTION_AGE_MS 9999
static void *tag(intptr_t t) { return (void *)t; }
@ -59,11 +57,11 @@ static void test_max_connection_idle(grpc_end2end_test_config config) {
.key = "grpc.testing.fixed_reconnect_backoff_ms",
.value.integer = 1000}};
grpc_arg server_a[] = {{.type = GRPC_ARG_INTEGER,
.key = GRPC_ARG_MAX_CONNECTION_IDLE_S,
.value.integer = MAX_CONNECTION_IDLE_S},
.key = GRPC_ARG_MAX_CONNECTION_IDLE_MS,
.value.integer = MAX_CONNECTION_IDLE_MS},
{.type = GRPC_ARG_INTEGER,
.key = GRPC_ARG_MAX_CONNECTION_AGE_S,
.value.integer = MAX_CONNECTION_AGE_S}};
.key = GRPC_ARG_MAX_CONNECTION_AGE_MS,
.value.integer = MAX_CONNECTION_AGE_MS}};
grpc_channel_args client_args = {.num_args = GPR_ARRAY_SIZE(client_a),
.args = client_a};
grpc_channel_args server_args = {.num_args = GPR_ARRAY_SIZE(server_a),
@ -91,7 +89,7 @@ static void test_max_connection_idle(grpc_end2end_test_config config) {
/* wait for the channel to reach its maximum idle time */
grpc_channel_watch_connectivity_state(
f.client, GRPC_CHANNEL_READY,
grpc_timeout_seconds_to_deadline(MAX_CONNECTION_IDLE_S + 1), f.cq,
grpc_timeout_milliseconds_to_deadline(MAX_CONNECTION_IDLE_MS + 500), f.cq,
tag(99));
CQ_EXPECT_COMPLETION(cqv, tag(99), 1);
cq_verify(cqv);

Write Preview
Loading…
Cancel
Save