mirror of https://github.com/grpc/grpc.git
Mark D. Roth
8 years ago
commit
9eee718e86
15 changed files with 389 additions and 100 deletions
@ -0,0 +1,276 @@ |
||||
//
|
||||
// Copyright 2016, 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.
|
||||
//
|
||||
|
||||
// This is similar to the sockaddr resolver, except that it supports a
|
||||
// bunch of query args that are useful for dependency injection in tests.
|
||||
|
||||
#include <stdbool.h> |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
|
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/host_port.h> |
||||
#include <grpc/support/port_platform.h> |
||||
#include <grpc/support/string_util.h> |
||||
|
||||
#include "src/core/ext/client_config/method_config.h" |
||||
#include "src/core/ext/client_config/parse_address.h" |
||||
#include "src/core/ext/client_config/resolver_registry.h" |
||||
#include "src/core/lib/channel/channel_args.h" |
||||
#include "src/core/lib/iomgr/resolve_address.h" |
||||
#include "src/core/lib/iomgr/unix_sockets_posix.h" |
||||
#include "src/core/lib/support/string.h" |
||||
|
||||
//
|
||||
// fake_resolver
|
||||
//
|
||||
|
||||
typedef struct { |
||||
// base class -- must be first
|
||||
grpc_resolver base; |
||||
|
||||
gpr_refcount refs; |
||||
|
||||
// passed-in parameters
|
||||
char* target_name; // the path component of the uri passed in
|
||||
grpc_lb_addresses* addresses; |
||||
char* lb_policy_name; |
||||
grpc_method_config_table* method_config_table; |
||||
|
||||
// mutex guarding the rest of the state
|
||||
gpr_mu mu; |
||||
// have we published?
|
||||
bool published; |
||||
// pending next completion, or NULL
|
||||
grpc_closure* next_completion; |
||||
// target result address for next completion
|
||||
grpc_resolver_result** target_result; |
||||
} fake_resolver; |
||||
|
||||
static void fake_resolver_destroy(grpc_exec_ctx* exec_ctx, grpc_resolver* gr) { |
||||
fake_resolver* r = (fake_resolver*)gr; |
||||
gpr_mu_destroy(&r->mu); |
||||
gpr_free(r->target_name); |
||||
grpc_lb_addresses_destroy(r->addresses, NULL /* user_data_destroy */); |
||||
gpr_free(r->lb_policy_name); |
||||
grpc_method_config_table_unref(r->method_config_table); |
||||
gpr_free(r); |
||||
} |
||||
|
||||
static void fake_resolver_shutdown(grpc_exec_ctx* exec_ctx, |
||||
grpc_resolver* resolver) { |
||||
fake_resolver* r = (fake_resolver*)resolver; |
||||
gpr_mu_lock(&r->mu); |
||||
if (r->next_completion != NULL) { |
||||
*r->target_result = NULL; |
||||
grpc_exec_ctx_sched(exec_ctx, r->next_completion, GRPC_ERROR_NONE, NULL); |
||||
r->next_completion = NULL; |
||||
} |
||||
gpr_mu_unlock(&r->mu); |
||||
} |
||||
|
||||
static void fake_resolver_maybe_finish_next_locked(grpc_exec_ctx* exec_ctx, |
||||
fake_resolver* r) { |
||||
if (r->next_completion != NULL && !r->published) { |
||||
r->published = true; |
||||
grpc_channel_args* lb_policy_args = NULL; |
||||
if (r->method_config_table != NULL) { |
||||
const grpc_arg arg = |
||||
grpc_method_config_table_create_channel_arg(r->method_config_table); |
||||
lb_policy_args = grpc_channel_args_copy_and_add(NULL /* src */, &arg, 1); |
||||
} |
||||
*r->target_result = grpc_resolver_result_create( |
||||
r->target_name, |
||||
grpc_lb_addresses_copy(r->addresses, NULL /* user_data_copy */), |
||||
r->lb_policy_name, lb_policy_args); |
||||
grpc_exec_ctx_sched(exec_ctx, r->next_completion, GRPC_ERROR_NONE, NULL); |
||||
r->next_completion = NULL; |
||||
} |
||||
} |
||||
|
||||
static void fake_resolver_channel_saw_error(grpc_exec_ctx* exec_ctx, |
||||
grpc_resolver* resolver) { |
||||
fake_resolver* r = (fake_resolver*)resolver; |
||||
gpr_mu_lock(&r->mu); |
||||
r->published = false; |
||||
fake_resolver_maybe_finish_next_locked(exec_ctx, r); |
||||
gpr_mu_unlock(&r->mu); |
||||
} |
||||
|
||||
static void fake_resolver_next(grpc_exec_ctx* exec_ctx, grpc_resolver* resolver, |
||||
grpc_resolver_result** target_result, |
||||
grpc_closure* on_complete) { |
||||
fake_resolver* r = (fake_resolver*)resolver; |
||||
gpr_mu_lock(&r->mu); |
||||
GPR_ASSERT(!r->next_completion); |
||||
r->next_completion = on_complete; |
||||
r->target_result = target_result; |
||||
fake_resolver_maybe_finish_next_locked(exec_ctx, r); |
||||
gpr_mu_unlock(&r->mu); |
||||
} |
||||
|
||||
static const grpc_resolver_vtable fake_resolver_vtable = { |
||||
fake_resolver_destroy, fake_resolver_shutdown, |
||||
fake_resolver_channel_saw_error, fake_resolver_next}; |
||||
|
||||
//
|
||||
// fake_resolver_factory
|
||||
//
|
||||
|
||||
static void fake_resolver_factory_ref(grpc_resolver_factory* factory) {} |
||||
|
||||
static void fake_resolver_factory_unref(grpc_resolver_factory* factory) {} |
||||
|
||||
static void do_nothing(void* ignored) {} |
||||
|
||||
static grpc_resolver* fake_resolver_create(grpc_resolver_factory* factory, |
||||
grpc_resolver_args* args) { |
||||
if (0 != strcmp(args->uri->authority, "")) { |
||||
gpr_log(GPR_ERROR, "authority based uri's not supported by the %s scheme", |
||||
args->uri->scheme); |
||||
return NULL; |
||||
} |
||||
fake_resolver* r = gpr_malloc(sizeof(fake_resolver)); |
||||
memset(r, 0, sizeof(*r)); |
||||
r->target_name = gpr_strdup(args->uri->path); |
||||
// Initialize LB policy name.
|
||||
r->lb_policy_name = |
||||
gpr_strdup(grpc_uri_get_query_arg(args->uri, "lb_policy")); |
||||
if (r->lb_policy_name == NULL) { |
||||
r->lb_policy_name = gpr_strdup("pick_first"); |
||||
} |
||||
// Get lb_enabled arg.
|
||||
const char* lb_enabled_qpart = |
||||
grpc_uri_get_query_arg(args->uri, "lb_enabled"); |
||||
// Anything other than "0" is interpreted as true.
|
||||
const bool lb_enabled = |
||||
lb_enabled_qpart != NULL && strcmp("0", lb_enabled_qpart) != 0; |
||||
if (strcmp("grpclb", r->lb_policy_name) == 0 && !lb_enabled) { |
||||
// we want grpclb but the "resolved" addresses aren't LB enabled. Bail
|
||||
// out, as this is meant mostly for tests.
|
||||
gpr_log(GPR_ERROR, |
||||
"Requested 'grpclb' LB policy but resolved addresses don't " |
||||
"support load balancing."); |
||||
abort(); |
||||
} |
||||
// Construct addresses.
|
||||
gpr_slice path_slice = |
||||
gpr_slice_new(args->uri->path, strlen(args->uri->path), do_nothing); |
||||
gpr_slice_buffer path_parts; |
||||
gpr_slice_buffer_init(&path_parts); |
||||
gpr_slice_split(path_slice, ",", &path_parts); |
||||
r->addresses = grpc_lb_addresses_create(path_parts.count); |
||||
bool errors_found = false; |
||||
for (size_t i = 0; i < r->addresses->num_addresses; i++) { |
||||
grpc_uri ith_uri = *args->uri; |
||||
char* part_str = gpr_dump_slice(path_parts.slices[i], GPR_DUMP_ASCII); |
||||
ith_uri.path = part_str; |
||||
if (!parse_ipv4(&ith_uri, |
||||
(struct sockaddr_storage*)(&r->addresses->addresses[i] |
||||
.address.addr), |
||||
&r->addresses->addresses[i].address.len)) { |
||||
errors_found = true; |
||||
} |
||||
gpr_free(part_str); |
||||
r->addresses->addresses[i].is_balancer = lb_enabled; |
||||
if (errors_found) break; |
||||
} |
||||
gpr_slice_buffer_destroy(&path_parts); |
||||
gpr_slice_unref(path_slice); |
||||
if (errors_found) { |
||||
gpr_free(r->lb_policy_name); |
||||
gpr_free(r->target_name); |
||||
grpc_lb_addresses_destroy(r->addresses, NULL /* user_data_destroy */); |
||||
gpr_free(r); |
||||
return NULL; |
||||
} |
||||
// Construct method config table.
|
||||
// We only support parameters for a single method.
|
||||
const char* method_name = grpc_uri_get_query_arg(args->uri, "method_name"); |
||||
if (method_name != NULL) { |
||||
const char* wait_for_ready_str = |
||||
grpc_uri_get_query_arg(args->uri, "wait_for_ready"); |
||||
// Anything other than "0" is interpreted as true.
|
||||
bool wait_for_ready = |
||||
wait_for_ready_str != NULL && strcmp("0", wait_for_ready_str) != 0; |
||||
const char* timeout_str = |
||||
grpc_uri_get_query_arg(args->uri, "timeout_seconds"); |
||||
gpr_timespec timeout = {timeout_str == NULL ? 0 : atoi(timeout_str), 0, |
||||
GPR_CLOCK_MONOTONIC}; |
||||
const char* max_request_message_bytes_str = |
||||
grpc_uri_get_query_arg(args->uri, "max_request_message_bytes"); |
||||
int32_t max_request_message_bytes = |
||||
max_request_message_bytes_str == NULL |
||||
? 0 |
||||
: atoi(max_request_message_bytes_str); |
||||
const char* max_response_message_bytes_str = |
||||
grpc_uri_get_query_arg(args->uri, "max_response_message_bytes"); |
||||
int32_t max_response_message_bytes = |
||||
max_response_message_bytes_str == NULL |
||||
? 0 |
||||
: atoi(max_response_message_bytes_str); |
||||
grpc_method_config* method_config = grpc_method_config_create( |
||||
wait_for_ready_str == NULL ? NULL : &wait_for_ready, |
||||
timeout_str == NULL ? NULL : &timeout, |
||||
max_request_message_bytes_str == NULL ? NULL |
||||
: &max_request_message_bytes, |
||||
max_response_message_bytes_str == NULL ? NULL |
||||
: &max_response_message_bytes); |
||||
grpc_method_config_table_entry entry = {grpc_mdstr_from_string(method_name), |
||||
method_config}; |
||||
r->method_config_table = grpc_method_config_table_create(1, &entry); |
||||
GRPC_MDSTR_UNREF(entry.method_name); |
||||
grpc_method_config_unref(method_config); |
||||
} |
||||
gpr_ref_init(&r->refs, 1); |
||||
gpr_mu_init(&r->mu); |
||||
grpc_resolver_init(&r->base, &fake_resolver_vtable); |
||||
return &r->base; |
||||
} |
||||
|
||||
static char* fake_resolver_get_default_authority(grpc_resolver_factory* factory, |
||||
grpc_uri* uri) { |
||||
const char* path = uri->path; |
||||
if (path[0] == '/') ++path; |
||||
return gpr_strdup(path); |
||||
} |
||||
|
||||
static const grpc_resolver_factory_vtable fake_resolver_factory_vtable = { |
||||
fake_resolver_factory_ref, fake_resolver_factory_unref, |
||||
fake_resolver_create, fake_resolver_get_default_authority, "test"}; |
||||
|
||||
static grpc_resolver_factory fake_resolver_factory = { |
||||
&fake_resolver_factory_vtable}; |
||||
|
||||
void grpc_fake_resolver_init(void) { |
||||
grpc_register_resolver_type(&fake_resolver_factory); |
||||
} |
||||
@ -0,0 +1,39 @@ |
||||
//
|
||||
// Copyright 2016, 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.
|
||||
//
|
||||
|
||||
#ifndef GRPC_TEST_CORE_END2END_FAKE_RESOLVER_H |
||||
#define GRPC_TEST_CORE_END2END_FAKE_RESOLVER_H |
||||
|
||||
#include "test/core/util/test_config.h" |
||||
|
||||
void grpc_fake_resolver_init(); |
||||
|
||||
#endif /* GRPC_TEST_CORE_END2END_FAKE_RESOLVER_H */ |
||||
Loading…
Reference in new issue