test/core/client_channel/resolvers/dns_resolver_cooldown_test.cc

   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 #include <cstring>
  20
  21 #include <grpc/support/log.h>
  22
  23 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
  24 #include "src/core/ext/filters/client_channel/resolver_registry.h"
  25 #include "src/core/ext/filters/client_channel/server_address.h"
  26 #include "src/core/lib/channel/channel_args.h"
  27 #include "src/core/lib/gprpp/memory.h"
  28 #include "src/core/lib/iomgr/combiner.h"
  29 #include "src/core/lib/iomgr/sockaddr_utils.h"
  30 #include "test/core/util/test_config.h"
  31
  32 constexpr int kMinResolutionPeriodMs = 1000;
  33 // Provide some slack when checking intervals, to allow for test timing issues.
  34 constexpr int kMinResolutionPeriodForCheckMs = 900;
  35
  36 extern grpc_address_resolver_vtable* grpc_resolve_address_impl;
  37 static grpc_address_resolver_vtable* default_resolve_address;
  38
  39 static grpc_combiner* g_combiner;
  40
  41 static grpc_ares_request* (*g_default_dns_lookup_ares_locked)(
  42     const char* dns_server, const char* name, const char* default_port,
  43     grpc_pollset_set* interested_parties, grpc_closure* on_done,
  44     grpc_core::UniquePtr<grpc_core::ServerAddressList>* addresses,
  45     bool check_grpclb, char** service_config_json, int query_timeout_ms,
  46     grpc_combiner* combiner);
  47
  48 // Counter incremented by test_resolve_address_impl indicating the number of
  49 // times a system-level resolution has happened.
  50 static int g_resolution_count;
  51
  52 static struct iomgr_args {
  53   gpr_event ev;
  54   gpr_atm done_atm;
  55   gpr_mu* mu;
  56   grpc_pollset* pollset;
  57   grpc_pollset_set* pollset_set;
  58 } g_iomgr_args;
  59
  60 // Wrapper around default resolve_address in order to count the number of
  61 // times we incur in a system-level name resolution.
  62 static void test_resolve_address_impl(const char* name,
  63                                       const char* default_port,
  64                                       grpc_pollset_set* interested_parties,
  65                                       grpc_closure* on_done,
  66                                       grpc_resolved_addresses** addrs) {
  67   default_resolve_address->resolve_address(
  68       name, default_port, g_iomgr_args.pollset_set, on_done, addrs);
  69   ++g_resolution_count;
  70   static grpc_millis last_resolution_time = 0;
  71   if (last_resolution_time == 0) {
  72     last_resolution_time =
  73         grpc_timespec_to_millis_round_up(gpr_now(GPR_CLOCK_MONOTONIC));
  74   } else {
  75     grpc_millis now =
  76         grpc_timespec_to_millis_round_up(gpr_now(GPR_CLOCK_MONOTONIC));
  77     GPR_ASSERT(now - last_resolution_time >= kMinResolutionPeriodForCheckMs);
  78     last_resolution_time = now;
  79   }
  80 }
  81
  82 static grpc_error* test_blocking_resolve_address_impl(
  83     const char* name, const char* default_port,
  84     grpc_resolved_addresses** addresses) {
  85   return default_resolve_address->blocking_resolve_address(name, default_port,
  86                                                            addresses);
  87 }
  88
  89 static grpc_address_resolver_vtable test_resolver = {
  90     test_resolve_address_impl, test_blocking_resolve_address_impl};
  91
  92 static grpc_ares_request* test_dns_lookup_ares_locked(
  93     const char* dns_server, const char* name, const char* default_port,
  94     grpc_pollset_set* interested_parties, grpc_closure* on_done,
  95     grpc_core::UniquePtr<grpc_core::ServerAddressList>* addresses,
  96     bool check_grpclb, char** service_config_json, int query_timeout_ms,
  97     grpc_combiner* combiner) {
  98   grpc_ares_request* result = g_default_dns_lookup_ares_locked(
  99       dns_server, name, default_port, g_iomgr_args.pollset_set, on_done,
 100       addresses, check_grpclb, service_config_json, query_timeout_ms, combiner);
 101   ++g_resolution_count;
 102   static grpc_millis last_resolution_time = 0;
 103   if (last_resolution_time == 0) {
 104     last_resolution_time =
 105         grpc_timespec_to_millis_round_up(gpr_now(GPR_CLOCK_MONOTONIC));
 106   } else {
 107     grpc_millis now =
 108         grpc_timespec_to_millis_round_up(gpr_now(GPR_CLOCK_MONOTONIC));
 109     GPR_ASSERT(now - last_resolution_time >= kMinResolutionPeriodForCheckMs);
 110     last_resolution_time = now;
 111   }
 112   return result;
 113 }
 114
 115 static gpr_timespec test_deadline(void) {
 116   return grpc_timeout_seconds_to_deadline(100);
 117 }
 118
 119 static void do_nothing(void* arg, grpc_error* error) {}
 120
 121 static void iomgr_args_init(iomgr_args* args) {
 122   gpr_event_init(&args->ev);
 123   args->pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
 124   grpc_pollset_init(args->pollset, &args->mu);
 125   args->pollset_set = grpc_pollset_set_create();
 126   grpc_pollset_set_add_pollset(args->pollset_set, args->pollset);
 127   gpr_atm_rel_store(&args->done_atm, 0);
 128 }
 129
 130 static void iomgr_args_finish(iomgr_args* args) {
 131   GPR_ASSERT(gpr_event_wait(&args->ev, test_deadline()));
 132   grpc_pollset_set_del_pollset(args->pollset_set, args->pollset);
 133   grpc_pollset_set_destroy(args->pollset_set);
 134   grpc_closure do_nothing_cb;
 135   GRPC_CLOSURE_INIT(&do_nothing_cb, do_nothing, nullptr,
 136                     grpc_schedule_on_exec_ctx);
 137   gpr_mu_lock(args->mu);
 138   grpc_pollset_shutdown(args->pollset, &do_nothing_cb);
 139   gpr_mu_unlock(args->mu);
 140   // exec_ctx needs to be flushed before calling grpc_pollset_destroy()
 141   grpc_core::ExecCtx::Get()->Flush();
 142   grpc_pollset_destroy(args->pollset);
 143   gpr_free(args->pollset);
 144 }
 145
 146 static grpc_millis n_sec_deadline(int seconds) {
 147   return grpc_timespec_to_millis_round_up(
 148       grpc_timeout_seconds_to_deadline(seconds));
 149 }
 150
 151 static void poll_pollset_until_request_done(iomgr_args* args) {
 152   grpc_core::ExecCtx exec_ctx;
 153   grpc_millis deadline = n_sec_deadline(10);
 154   while (true) {
 155     bool done = gpr_atm_acq_load(&args->done_atm) != 0;
 156     if (done) {
 157       break;
 158     }
 159     grpc_millis time_left = deadline - grpc_core::ExecCtx::Get()->Now();
 160     gpr_log(GPR_DEBUG, "done=%d, time_left=%" PRId64, done, time_left);
 161     GPR_ASSERT(time_left >= 0);
 162     grpc_pollset_worker* worker = nullptr;
 163     gpr_mu_lock(args->mu);
 164     GRPC_LOG_IF_ERROR("pollset_work", grpc_pollset_work(args->pollset, &worker,
 165                                                         n_sec_deadline(1)));
 166     gpr_mu_unlock(args->mu);
 167     grpc_core::ExecCtx::Get()->Flush();
 168   }
 169   gpr_event_set(&args->ev, (void*)1);
 170 }
 171
 172 struct OnResolutionCallbackArg {
 173   const char* uri_str = nullptr;
 174   grpc_core::OrphanablePtr<grpc_core::Resolver> resolver;
 175   grpc_channel_args* result = nullptr;
 176 };
 177
 178 // Set to true by the last callback in the resolution chain.
 179 static bool g_all_callbacks_invoked;
 180
 181 static void on_second_resolution(void* arg, grpc_error* error) {
 182   OnResolutionCallbackArg* cb_arg = static_cast<OnResolutionCallbackArg*>(arg);
 183   grpc_channel_args_destroy(cb_arg->result);
 184   GPR_ASSERT(error == GRPC_ERROR_NONE);
 185   gpr_log(GPR_INFO, "2nd: g_resolution_count: %d", g_resolution_count);
 186   // The resolution callback was not invoked until new data was
 187   // available, which was delayed until after the cooldown period.
 188   GPR_ASSERT(g_resolution_count == 2);
 189   cb_arg->resolver.reset();
 190   gpr_atm_rel_store(&g_iomgr_args.done_atm, 1);
 191   gpr_mu_lock(g_iomgr_args.mu);
 192   GRPC_LOG_IF_ERROR("pollset_kick",
 193                     grpc_pollset_kick(g_iomgr_args.pollset, nullptr));
 194   gpr_mu_unlock(g_iomgr_args.mu);
 195   grpc_core::Delete(cb_arg);
 196   g_all_callbacks_invoked = true;
 197 }
 198
 199 static void on_first_resolution(void* arg, grpc_error* error) {
 200   OnResolutionCallbackArg* cb_arg = static_cast<OnResolutionCallbackArg*>(arg);
 201   grpc_channel_args_destroy(cb_arg->result);
 202   GPR_ASSERT(error == GRPC_ERROR_NONE);
 203   gpr_log(GPR_INFO, "1st: g_resolution_count: %d", g_resolution_count);
 204   // There's one initial system-level resolution and one invocation of a
 205   // notification callback (the current function).
 206   GPR_ASSERT(g_resolution_count == 1);
 207   cb_arg->resolver->NextLocked(
 208       &cb_arg->result,
 209       GRPC_CLOSURE_CREATE(on_second_resolution, arg,
 210                           grpc_combiner_scheduler(g_combiner)));
 211   cb_arg->resolver->RequestReresolutionLocked();
 212   gpr_mu_lock(g_iomgr_args.mu);
 213   GRPC_LOG_IF_ERROR("pollset_kick",
 214                     grpc_pollset_kick(g_iomgr_args.pollset, nullptr));
 215   gpr_mu_unlock(g_iomgr_args.mu);
 216 }
 217
 218 static void start_test_under_combiner(void* arg, grpc_error* error) {
 219   OnResolutionCallbackArg* res_cb_arg =
 220       static_cast<OnResolutionCallbackArg*>(arg);
 221
 222   grpc_core::ResolverFactory* factory =
 223       grpc_core::ResolverRegistry::LookupResolverFactory("dns");
 224   grpc_uri* uri = grpc_uri_parse(res_cb_arg->uri_str, 0);
 225   gpr_log(GPR_DEBUG, "test: '%s' should be valid for '%s'", res_cb_arg->uri_str,
 226           factory->scheme());
 227   GPR_ASSERT(uri != nullptr);
 228   grpc_core::ResolverArgs args;
 229   args.uri = uri;
 230   args.combiner = g_combiner;
 231   g_resolution_count = 0;
 232
 233   grpc_arg cooldown_arg;
 234   cooldown_arg.key =
 235       const_cast<char*>(GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS);
 236   cooldown_arg.type = GRPC_ARG_INTEGER;
 237   cooldown_arg.value.integer = kMinResolutionPeriodMs;
 238   auto* cooldown_channel_args =
 239       grpc_channel_args_copy_and_add(nullptr, &cooldown_arg, 1);
 240   args.args = cooldown_channel_args;
 241   res_cb_arg->resolver = factory->CreateResolver(args);
 242   grpc_channel_args_destroy(cooldown_channel_args);
 243   GPR_ASSERT(res_cb_arg->resolver != nullptr);
 244   // First resolution, would incur in system-level resolution.
 245   res_cb_arg->resolver->NextLocked(
 246       &res_cb_arg->result,
 247       GRPC_CLOSURE_CREATE(on_first_resolution, res_cb_arg,
 248                           grpc_combiner_scheduler(g_combiner)));
 249   grpc_uri_destroy(uri);
 250 }
 251
 252 static void test_cooldown() {
 253   grpc_core::ExecCtx exec_ctx;
 254   iomgr_args_init(&g_iomgr_args);
 255   OnResolutionCallbackArg* res_cb_arg =
 256       grpc_core::New<OnResolutionCallbackArg>();
 257   res_cb_arg->uri_str = "dns:127.0.0.1";
 258
 259   GRPC_CLOSURE_SCHED(GRPC_CLOSURE_CREATE(start_test_under_combiner, res_cb_arg,
 260                                          grpc_combiner_scheduler(g_combiner)),
 261                      GRPC_ERROR_NONE);
 262   grpc_core::ExecCtx::Get()->Flush();
 263   poll_pollset_until_request_done(&g_iomgr_args);
 264   iomgr_args_finish(&g_iomgr_args);
 265 }
 266
 267 int main(int argc, char** argv) {
 268   grpc::testing::TestEnvironment env(argc, argv);
 269   grpc_init();
 270
 271   g_combiner = grpc_combiner_create();
 272
 273   g_default_dns_lookup_ares_locked = grpc_dns_lookup_ares_locked;
 274   grpc_dns_lookup_ares_locked = test_dns_lookup_ares_locked;
 275   default_resolve_address = grpc_resolve_address_impl;
 276   grpc_set_resolver_impl(&test_resolver);
 277
 278   test_cooldown();
 279
 280   {
 281     grpc_core::ExecCtx exec_ctx;
 282     GRPC_COMBINER_UNREF(g_combiner, "test");
 283   }
 284   grpc_shutdown();
 285   GPR_ASSERT(g_all_callbacks_invoked);
 286   return 0;
 287 }