From f23078cbd302d32649537eedda1769c5685228d8 Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Fri, 25 Mar 2016 17:07:29 -0700 Subject: Stage #1 of core breakup: move everything under lib --- src/core/lib/client_config/README.md | 66 ++ src/core/lib/client_config/client_config.c | 74 +++ src/core/lib/client_config/client_config.h | 53 ++ src/core/lib/client_config/connector.c | 55 ++ src/core/lib/client_config/connector.h | 92 +++ .../client_config/default_initial_connect_string.c | 39 ++ .../lib/client_config/initial_connect_string.c | 53 ++ .../lib/client_config/initial_connect_string.h | 50 ++ .../client_config/lb_policies/load_balancer_api.c | 163 +++++ .../client_config/lb_policies/load_balancer_api.h | 85 +++ .../lib/client_config/lb_policies/pick_first.c | 421 +++++++++++++ .../lib/client_config/lb_policies/pick_first.h | 43 ++ .../lib/client_config/lb_policies/round_robin.c | 542 ++++++++++++++++ .../lib/client_config/lb_policies/round_robin.h | 46 ++ src/core/lib/client_config/lb_policy.c | 134 ++++ src/core/lib/client_config/lb_policy.h | 144 +++++ src/core/lib/client_config/lb_policy_factory.c | 48 ++ src/core/lib/client_config/lb_policy_factory.h | 73 +++ src/core/lib/client_config/lb_policy_registry.c | 88 +++ src/core/lib/client_config/lb_policy_registry.h | 54 ++ src/core/lib/client_config/resolver.c | 82 +++ src/core/lib/client_config/resolver.h | 94 +++ src/core/lib/client_config/resolver_factory.c | 55 ++ src/core/lib/client_config/resolver_factory.h | 82 +++ src/core/lib/client_config/resolver_registry.c | 137 +++++ src/core/lib/client_config/resolver_registry.h | 65 ++ .../lib/client_config/resolvers/dns_resolver.c | 309 ++++++++++ .../lib/client_config/resolvers/dns_resolver.h | 42 ++ .../client_config/resolvers/sockaddr_resolver.c | 372 +++++++++++ .../client_config/resolvers/sockaddr_resolver.h | 50 ++ .../client_config/resolvers/zookeeper_resolver.c | 520 ++++++++++++++++ .../client_config/resolvers/zookeeper_resolver.h | 42 ++ src/core/lib/client_config/subchannel.c | 678 +++++++++++++++++++++ src/core/lib/client_config/subchannel.h | 174 ++++++ src/core/lib/client_config/subchannel_factory.c | 49 ++ src/core/lib/client_config/subchannel_factory.h | 66 ++ src/core/lib/client_config/subchannel_index.c | 262 ++++++++ src/core/lib/client_config/subchannel_index.h | 77 +++ src/core/lib/client_config/uri_parser.c | 242 ++++++++ src/core/lib/client_config/uri_parser.h | 51 ++ 40 files changed, 5772 insertions(+) create mode 100644 src/core/lib/client_config/README.md create mode 100644 src/core/lib/client_config/client_config.c create mode 100644 src/core/lib/client_config/client_config.h create mode 100644 src/core/lib/client_config/connector.c create mode 100644 src/core/lib/client_config/connector.h create mode 100644 src/core/lib/client_config/default_initial_connect_string.c create mode 100644 src/core/lib/client_config/initial_connect_string.c create mode 100644 src/core/lib/client_config/initial_connect_string.h create mode 100644 src/core/lib/client_config/lb_policies/load_balancer_api.c create mode 100644 src/core/lib/client_config/lb_policies/load_balancer_api.h create mode 100644 src/core/lib/client_config/lb_policies/pick_first.c create mode 100644 src/core/lib/client_config/lb_policies/pick_first.h create mode 100644 src/core/lib/client_config/lb_policies/round_robin.c create mode 100644 src/core/lib/client_config/lb_policies/round_robin.h create mode 100644 src/core/lib/client_config/lb_policy.c create mode 100644 src/core/lib/client_config/lb_policy.h create mode 100644 src/core/lib/client_config/lb_policy_factory.c create mode 100644 src/core/lib/client_config/lb_policy_factory.h create mode 100644 src/core/lib/client_config/lb_policy_registry.c create mode 100644 src/core/lib/client_config/lb_policy_registry.h create mode 100644 src/core/lib/client_config/resolver.c create mode 100644 src/core/lib/client_config/resolver.h create mode 100644 src/core/lib/client_config/resolver_factory.c create mode 100644 src/core/lib/client_config/resolver_factory.h create mode 100644 src/core/lib/client_config/resolver_registry.c create mode 100644 src/core/lib/client_config/resolver_registry.h create mode 100644 src/core/lib/client_config/resolvers/dns_resolver.c create mode 100644 src/core/lib/client_config/resolvers/dns_resolver.h create mode 100644 src/core/lib/client_config/resolvers/sockaddr_resolver.c create mode 100644 src/core/lib/client_config/resolvers/sockaddr_resolver.h create mode 100644 src/core/lib/client_config/resolvers/zookeeper_resolver.c create mode 100644 src/core/lib/client_config/resolvers/zookeeper_resolver.h create mode 100644 src/core/lib/client_config/subchannel.c create mode 100644 src/core/lib/client_config/subchannel.h create mode 100644 src/core/lib/client_config/subchannel_factory.c create mode 100644 src/core/lib/client_config/subchannel_factory.h create mode 100644 src/core/lib/client_config/subchannel_index.c create mode 100644 src/core/lib/client_config/subchannel_index.h create mode 100644 src/core/lib/client_config/uri_parser.c create mode 100644 src/core/lib/client_config/uri_parser.h (limited to 'src/core/lib/client_config') diff --git a/src/core/lib/client_config/README.md b/src/core/lib/client_config/README.md new file mode 100644 index 0000000000..fff7a5af5b --- /dev/null +++ b/src/core/lib/client_config/README.md @@ -0,0 +1,66 @@ +Client Configuration Support for GRPC +===================================== + +This library provides high level configuration machinery to construct client +channels and load balance between them. + +Each grpc_channel is created with a grpc_resolver. It is the resolver's duty +to resolve a name into configuration data for the channel. Such configuration +data might include: + +- a list of (ip, port) addresses to connect to +- a load balancing policy to decide which server to send a request to +- a set of filters to mutate outgoing requests (say, by adding metadata) + +The resolver provides this data as a stream of grpc_client_config objects to +the channel. We represent configuration as a stream so that it can be changed +by the resolver during execution, by reacting to external events (such as a +new configuration file being pushed to some store). + + +Load Balancing +-------------- + +Load balancing configuration is provided by a grpc_lb_policy object, stored as +part of grpc_client_config. + +The primary job of the load balancing policies is to pick a target server given only the +initial metadata for a request. It does this by providing a grpc_subchannel +object to the owning channel. + + +Sub-Channels +------------ + +A sub-channel provides a connection to a server for a client channel. It has a +connectivity state like a regular channel, and so can be connected or +disconnected. This connectivity state can be used to inform load balancing +decisions (for example, by avoiding disconnected backends). + +Configured sub-channels are fully setup to participate in the grpc data plane. +Their behavior is specified by a set of grpc channel filters defined at their +construction. To customize this behavior, resolvers build +grpc_subchannel_factory objects, which use the decorator pattern to customize +construction arguments for concrete grpc_subchannel instances. + + +Naming for GRPC +=============== + +Names in GRPC are represented by a URI (as defined in +[RFC 3986](https://tools.ietf.org/html/rfc3986)). + +The following schemes are currently supported: + +dns:///host:port - dns schemes are currently supported so long as authority is + empty (authority based dns resolution is expected in a future + release) + +unix:path - the unix scheme is used to create and connect to unix domain + sockets - the authority must be empty, and the path + represents the absolute or relative path to the desired + socket + +ipv4:host:port - a pre-resolved ipv4 dotted decimal address/port combination + +ipv6:[host]:port - a pre-resolved ipv6 address/port combination diff --git a/src/core/lib/client_config/client_config.c b/src/core/lib/client_config/client_config.c new file mode 100644 index 0000000000..c500af25ee --- /dev/null +++ b/src/core/lib/client_config/client_config.c @@ -0,0 +1,74 @@ +/* + * + * Copyright 2015-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. + * + */ + +#include "src/core/client_config/client_config.h" + +#include + +#include + +struct grpc_client_config { + gpr_refcount refs; + grpc_lb_policy *lb_policy; +}; + +grpc_client_config *grpc_client_config_create() { + grpc_client_config *c = gpr_malloc(sizeof(*c)); + memset(c, 0, sizeof(*c)); + gpr_ref_init(&c->refs, 1); + return c; +} + +void grpc_client_config_ref(grpc_client_config *c) { gpr_ref(&c->refs); } + +void grpc_client_config_unref(grpc_exec_ctx *exec_ctx, grpc_client_config *c) { + if (gpr_unref(&c->refs)) { + if (c->lb_policy != NULL) { + GRPC_LB_POLICY_UNREF(exec_ctx, c->lb_policy, "client_config"); + } + gpr_free(c); + } +} + +void grpc_client_config_set_lb_policy(grpc_client_config *c, + grpc_lb_policy *lb_policy) { + GPR_ASSERT(c->lb_policy == NULL); + if (lb_policy) { + GRPC_LB_POLICY_REF(lb_policy, "client_config"); + } + c->lb_policy = lb_policy; +} + +grpc_lb_policy *grpc_client_config_get_lb_policy(grpc_client_config *c) { + return c->lb_policy; +} diff --git a/src/core/lib/client_config/client_config.h b/src/core/lib/client_config/client_config.h new file mode 100644 index 0000000000..9b37fdc211 --- /dev/null +++ b/src/core/lib/client_config/client_config.h @@ -0,0 +1,53 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_CLIENT_CONFIG_H +#define GRPC_CORE_CLIENT_CONFIG_CLIENT_CONFIG_H + +#include "src/core/client_config/lb_policy.h" + +/** Total configuration for a client. Provided, and updated, by + grpc_resolver */ +typedef struct grpc_client_config grpc_client_config; + +grpc_client_config *grpc_client_config_create(); +void grpc_client_config_ref(grpc_client_config *client_config); +void grpc_client_config_unref(grpc_exec_ctx *exec_ctx, + grpc_client_config *client_config); + +void grpc_client_config_set_lb_policy(grpc_client_config *client_config, + grpc_lb_policy *lb_policy); +grpc_lb_policy *grpc_client_config_get_lb_policy( + grpc_client_config *client_config); + +#endif /* GRPC_CORE_CLIENT_CONFIG_CLIENT_CONFIG_H */ diff --git a/src/core/lib/client_config/connector.c b/src/core/lib/client_config/connector.c new file mode 100644 index 0000000000..aa34aa7fab --- /dev/null +++ b/src/core/lib/client_config/connector.c @@ -0,0 +1,55 @@ +/* + * + * Copyright 2015-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. + * + */ + +#include "src/core/client_config/connector.h" + +grpc_connector* grpc_connector_ref(grpc_connector* connector) { + connector->vtable->ref(connector); + return connector; +} + +void grpc_connector_unref(grpc_exec_ctx* exec_ctx, grpc_connector* connector) { + connector->vtable->unref(exec_ctx, connector); +} + +void grpc_connector_connect(grpc_exec_ctx* exec_ctx, grpc_connector* connector, + const grpc_connect_in_args* in_args, + grpc_connect_out_args* out_args, + grpc_closure* notify) { + connector->vtable->connect(exec_ctx, connector, in_args, out_args, notify); +} + +void grpc_connector_shutdown(grpc_exec_ctx* exec_ctx, + grpc_connector* connector) { + connector->vtable->shutdown(exec_ctx, connector); +} diff --git a/src/core/lib/client_config/connector.h b/src/core/lib/client_config/connector.h new file mode 100644 index 0000000000..93248fca4b --- /dev/null +++ b/src/core/lib/client_config/connector.h @@ -0,0 +1,92 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_CONNECTOR_H +#define GRPC_CORE_CLIENT_CONFIG_CONNECTOR_H + +#include "src/core/channel/channel_stack.h" +#include "src/core/iomgr/sockaddr.h" +#include "src/core/transport/transport.h" + +typedef struct grpc_connector grpc_connector; +typedef struct grpc_connector_vtable grpc_connector_vtable; + +struct grpc_connector { + const grpc_connector_vtable *vtable; +}; + +typedef struct { + /** set of pollsets interested in this connection */ + grpc_pollset_set *interested_parties; + /** address to connect to */ + const struct sockaddr *addr; + size_t addr_len; + /** initial connect string to send */ + gpr_slice initial_connect_string; + /** deadline for connection */ + gpr_timespec deadline; + /** channel arguments (to be passed to transport) */ + const grpc_channel_args *channel_args; +} grpc_connect_in_args; + +typedef struct { + /** the connected transport */ + grpc_transport *transport; + + /** channel arguments (to be passed to the filters) */ + const grpc_channel_args *channel_args; +} grpc_connect_out_args; + +struct grpc_connector_vtable { + void (*ref)(grpc_connector *connector); + void (*unref)(grpc_exec_ctx *exec_ctx, grpc_connector *connector); + /** Implementation of grpc_connector_shutdown */ + void (*shutdown)(grpc_exec_ctx *exec_ctx, grpc_connector *connector); + /** Implementation of grpc_connector_connect */ + void (*connect)(grpc_exec_ctx *exec_ctx, grpc_connector *connector, + const grpc_connect_in_args *in_args, + grpc_connect_out_args *out_args, grpc_closure *notify); +}; + +grpc_connector *grpc_connector_ref(grpc_connector *connector); +void grpc_connector_unref(grpc_exec_ctx *exec_ctx, grpc_connector *connector); +/** Connect using the connector: max one outstanding call at a time */ +void grpc_connector_connect(grpc_exec_ctx *exec_ctx, grpc_connector *connector, + const grpc_connect_in_args *in_args, + grpc_connect_out_args *out_args, + grpc_closure *notify); +/** Cancel any pending connection */ +void grpc_connector_shutdown(grpc_exec_ctx *exec_ctx, + grpc_connector *connector); + +#endif /* GRPC_CORE_CLIENT_CONFIG_CONNECTOR_H */ diff --git a/src/core/lib/client_config/default_initial_connect_string.c b/src/core/lib/client_config/default_initial_connect_string.c new file mode 100644 index 0000000000..6a4e23e6f2 --- /dev/null +++ b/src/core/lib/client_config/default_initial_connect_string.c @@ -0,0 +1,39 @@ +/* + * + * Copyright 2015, 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 +#include "src/core/iomgr/sockaddr.h" + +void grpc_set_default_initial_connect_string(struct sockaddr **addr, + size_t *addr_len, + gpr_slice *initial_str) {} diff --git a/src/core/lib/client_config/initial_connect_string.c b/src/core/lib/client_config/initial_connect_string.c new file mode 100644 index 0000000000..19afa1675a --- /dev/null +++ b/src/core/lib/client_config/initial_connect_string.c @@ -0,0 +1,53 @@ +/* + * + * Copyright 2015, 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/client_config/initial_connect_string.h" + +#include + +extern void grpc_set_default_initial_connect_string(struct sockaddr **addr, + size_t *addr_len, + gpr_slice *initial_str); + +static grpc_set_initial_connect_string_func g_set_initial_connect_string_func = + grpc_set_default_initial_connect_string; + +void grpc_test_set_initial_connect_string_function( + grpc_set_initial_connect_string_func func) { + g_set_initial_connect_string_func = func; +} + +void grpc_set_initial_connect_string(struct sockaddr **addr, size_t *addr_len, + gpr_slice *initial_str) { + g_set_initial_connect_string_func(addr, addr_len, initial_str); +} diff --git a/src/core/lib/client_config/initial_connect_string.h b/src/core/lib/client_config/initial_connect_string.h new file mode 100644 index 0000000000..e6d2d8f8fe --- /dev/null +++ b/src/core/lib/client_config/initial_connect_string.h @@ -0,0 +1,50 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_INITIAL_CONNECT_STRING_H +#define GRPC_CORE_CLIENT_CONFIG_INITIAL_CONNECT_STRING_H + +#include +#include "src/core/iomgr/sockaddr.h" + +typedef void (*grpc_set_initial_connect_string_func)(struct sockaddr **addr, + size_t *addr_len, + gpr_slice *initial_str); +void grpc_test_set_initial_connect_string_function( + grpc_set_initial_connect_string_func func); + +/** Set a string to be sent once connected. Optionally reset addr. */ +void grpc_set_initial_connect_string(struct sockaddr **addr, size_t *addr_len, + gpr_slice *connect_string); + +#endif /* GRPC_CORE_CLIENT_CONFIG_INITIAL_CONNECT_STRING_H */ diff --git a/src/core/lib/client_config/lb_policies/load_balancer_api.c b/src/core/lib/client_config/lb_policies/load_balancer_api.c new file mode 100644 index 0000000000..a6b5785fe4 --- /dev/null +++ b/src/core/lib/client_config/lb_policies/load_balancer_api.c @@ -0,0 +1,163 @@ +/* + * + * 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. + * + */ + +#include "src/core/client_config/lb_policies/load_balancer_api.h" +#include "third_party/nanopb/pb_decode.h" +#include "third_party/nanopb/pb_encode.h" + +#include + +typedef struct decode_serverlist_arg { + int first_pass; + int i; + size_t num_servers; + grpc_grpclb_server **servers; +} decode_serverlist_arg; + +/* invoked once for every Server in ServerList */ +static bool decode_serverlist(pb_istream_t *stream, const pb_field_t *field, + void **arg) { + decode_serverlist_arg *dec_arg = *arg; + if (dec_arg->first_pass != 0) { /* first pass */ + grpc_grpclb_server server; + if (!pb_decode(stream, grpc_lb_v0_Server_fields, &server)) { + return false; + } + dec_arg->num_servers++; + } else { /* second pass */ + grpc_grpclb_server *server = gpr_malloc(sizeof(grpc_grpclb_server)); + GPR_ASSERT(dec_arg->num_servers > 0); + if (dec_arg->i == 0) { /* first iteration of second pass */ + dec_arg->servers = + gpr_malloc(sizeof(grpc_grpclb_server *) * dec_arg->num_servers); + } + if (!pb_decode(stream, grpc_lb_v0_Server_fields, server)) { + return false; + } + dec_arg->servers[dec_arg->i++] = server; + } + + return true; +} + +grpc_grpclb_request *grpc_grpclb_request_create(const char *lb_service_name) { + grpc_grpclb_request *req = gpr_malloc(sizeof(grpc_grpclb_request)); + + req->has_client_stats = 0; /* TODO(dgq): add support for stats once defined */ + req->has_initial_request = 1; + req->initial_request.has_name = 1; + strncpy(req->initial_request.name, lb_service_name, + GRPC_GRPCLB_SERVICE_NAME_MAX_LENGTH); + return req; +} + +gpr_slice grpc_grpclb_request_encode(const grpc_grpclb_request *request) { + size_t encoded_length; + pb_ostream_t sizestream; + pb_ostream_t outputstream; + gpr_slice slice; + memset(&sizestream, 0, sizeof(pb_ostream_t)); + pb_encode(&sizestream, grpc_lb_v0_LoadBalanceRequest_fields, request); + encoded_length = sizestream.bytes_written; + + slice = gpr_slice_malloc(encoded_length); + outputstream = + pb_ostream_from_buffer(GPR_SLICE_START_PTR(slice), encoded_length); + GPR_ASSERT(pb_encode(&outputstream, grpc_lb_v0_LoadBalanceRequest_fields, + request) != 0); + return slice; +} + +void grpc_grpclb_request_destroy(grpc_grpclb_request *request) { + gpr_free(request); +} + +grpc_grpclb_response *grpc_grpclb_response_parse(gpr_slice encoded_response) { + bool status; + pb_istream_t stream = + pb_istream_from_buffer(GPR_SLICE_START_PTR(encoded_response), + GPR_SLICE_LENGTH(encoded_response)); + grpc_grpclb_response *res = gpr_malloc(sizeof(grpc_grpclb_response)); + memset(res, 0, sizeof(*res)); + status = pb_decode(&stream, grpc_lb_v0_LoadBalanceResponse_fields, res); + GPR_ASSERT(status == true); + return res; +} + +grpc_grpclb_serverlist *grpc_grpclb_response_parse_serverlist( + gpr_slice encoded_response) { + grpc_grpclb_serverlist *sl = gpr_malloc(sizeof(grpc_grpclb_serverlist)); + bool status; + decode_serverlist_arg arg; + pb_istream_t stream = + pb_istream_from_buffer(GPR_SLICE_START_PTR(encoded_response), + GPR_SLICE_LENGTH(encoded_response)); + pb_istream_t stream_at_start = stream; + grpc_grpclb_response *res = gpr_malloc(sizeof(grpc_grpclb_response)); + memset(res, 0, sizeof(*res)); + memset(&arg, 0, sizeof(decode_serverlist_arg)); + + res->server_list.servers.funcs.decode = decode_serverlist; + res->server_list.servers.arg = &arg; + arg.first_pass = 1; + status = pb_decode(&stream, grpc_lb_v0_LoadBalanceResponse_fields, res); + GPR_ASSERT(status == true); + GPR_ASSERT(arg.num_servers > 0); + + arg.first_pass = 0; + status = + pb_decode(&stream_at_start, grpc_lb_v0_LoadBalanceResponse_fields, res); + GPR_ASSERT(status == true); + GPR_ASSERT(arg.servers != NULL); + + sl->num_servers = arg.num_servers; + sl->servers = arg.servers; + if (res->server_list.has_expiration_interval) { + sl->expiration_interval = res->server_list.expiration_interval; + } + grpc_grpclb_response_destroy(res); + return sl; +} + +void grpc_grpclb_destroy_serverlist(grpc_grpclb_serverlist *serverlist) { + size_t i; + for (i = 0; i < serverlist->num_servers; i++) { + gpr_free(serverlist->servers[i]); + } + gpr_free(serverlist->servers); + gpr_free(serverlist); +} + +void grpc_grpclb_response_destroy(grpc_grpclb_response *response) { + gpr_free(response); +} diff --git a/src/core/lib/client_config/lb_policies/load_balancer_api.h b/src/core/lib/client_config/lb_policies/load_balancer_api.h new file mode 100644 index 0000000000..b7a4c9c8f5 --- /dev/null +++ b/src/core/lib/client_config/lb_policies/load_balancer_api.h @@ -0,0 +1,85 @@ +/* + * + * 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_CORE_CLIENT_CONFIG_LB_POLICIES_LOAD_BALANCER_API_H +#define GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_LOAD_BALANCER_API_H + +#include + +#include "src/core/client_config/lb_policy_factory.h" +#include "src/core/proto/grpc/lb/v0/load_balancer.pb.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define GRPC_GRPCLB_SERVICE_NAME_MAX_LENGTH 128 + +typedef grpc_lb_v0_LoadBalanceRequest grpc_grpclb_request; +typedef grpc_lb_v0_LoadBalanceResponse grpc_grpclb_response; +typedef grpc_lb_v0_Server grpc_grpclb_server; +typedef grpc_lb_v0_Duration grpc_grpclb_duration; +typedef struct grpc_grpclb_serverlist { + grpc_grpclb_server **servers; + size_t num_servers; + grpc_grpclb_duration expiration_interval; +} grpc_grpclb_serverlist; + +/** Create a request for a gRPC LB service under \a lb_service_name */ +grpc_grpclb_request *grpc_grpclb_request_create(const char *lb_service_name); + +/** Protocol Buffers v3-encode \a request */ +gpr_slice grpc_grpclb_request_encode(const grpc_grpclb_request *request); + +/** Destroy \a request */ +void grpc_grpclb_request_destroy(grpc_grpclb_request *request); + +/** Parse (ie, decode) the bytes in \a encoded_response as a \a + * grpc_grpclb_response */ +grpc_grpclb_response *grpc_grpclb_response_parse(gpr_slice encoded_response); + +/** Destroy \a serverlist */ +void grpc_grpclb_destroy_serverlist(grpc_grpclb_serverlist *serverlist); + +/** Parse the list of servers from an encoded \a grpc_grpclb_response */ +grpc_grpclb_serverlist *grpc_grpclb_response_parse_serverlist( + gpr_slice encoded_response); + +/** Destroy \a response */ +void grpc_grpclb_response_destroy(grpc_grpclb_response *response); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_LOAD_BALANCER_API_H */ diff --git a/src/core/lib/client_config/lb_policies/pick_first.c b/src/core/lib/client_config/lb_policies/pick_first.c new file mode 100644 index 0000000000..2833f112f4 --- /dev/null +++ b/src/core/lib/client_config/lb_policies/pick_first.c @@ -0,0 +1,421 @@ +/* + * + * Copyright 2015-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. + * + */ + +#include "src/core/client_config/lb_policies/pick_first.h" +#include "src/core/client_config/lb_policy_factory.h" + +#include + +#include +#include "src/core/transport/connectivity_state.h" + +typedef struct pending_pick { + struct pending_pick *next; + grpc_pollset *pollset; + grpc_connected_subchannel **target; + grpc_closure *on_complete; +} pending_pick; + +typedef struct { + /** base policy: must be first */ + grpc_lb_policy base; + /** all our subchannels */ + grpc_subchannel **subchannels; + size_t num_subchannels; + + grpc_closure connectivity_changed; + + /** the selected channel (a grpc_connected_subchannel) */ + gpr_atm selected; + + /** mutex protecting remaining members */ + gpr_mu mu; + /** have we started picking? */ + int started_picking; + /** are we shut down? */ + int shutdown; + /** which subchannel are we watching? */ + size_t checking_subchannel; + /** what is the connectivity of that channel? */ + grpc_connectivity_state checking_connectivity; + /** list of picks that are waiting on connectivity */ + pending_pick *pending_picks; + + /** our connectivity state tracker */ + grpc_connectivity_state_tracker state_tracker; +} pick_first_lb_policy; + +#define GET_SELECTED(p) \ + ((grpc_connected_subchannel *)gpr_atm_acq_load(&(p)->selected)) + +void pf_destroy(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) { + pick_first_lb_policy *p = (pick_first_lb_policy *)pol; + grpc_connected_subchannel *selected = GET_SELECTED(p); + size_t i; + GPR_ASSERT(p->pending_picks == NULL); + for (i = 0; i < p->num_subchannels; i++) { + GRPC_SUBCHANNEL_UNREF(exec_ctx, p->subchannels[i], "pick_first"); + } + if (selected != NULL) { + GRPC_CONNECTED_SUBCHANNEL_UNREF(exec_ctx, selected, "picked_first"); + } + grpc_connectivity_state_destroy(exec_ctx, &p->state_tracker); + gpr_free(p->subchannels); + gpr_mu_destroy(&p->mu); + gpr_free(p); +} + +void pf_shutdown(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) { + pick_first_lb_policy *p = (pick_first_lb_policy *)pol; + pending_pick *pp; + grpc_connected_subchannel *selected; + gpr_mu_lock(&p->mu); + selected = GET_SELECTED(p); + p->shutdown = 1; + pp = p->pending_picks; + p->pending_picks = NULL; + grpc_connectivity_state_set(exec_ctx, &p->state_tracker, + GRPC_CHANNEL_FATAL_FAILURE, "shutdown"); + /* cancel subscription */ + if (selected != NULL) { + grpc_connected_subchannel_notify_on_state_change( + exec_ctx, selected, NULL, NULL, &p->connectivity_changed); + } else { + grpc_subchannel_notify_on_state_change( + exec_ctx, p->subchannels[p->checking_subchannel], NULL, NULL, + &p->connectivity_changed); + } + gpr_mu_unlock(&p->mu); + while (pp != NULL) { + pending_pick *next = pp->next; + *pp->target = NULL; + grpc_pollset_set_del_pollset(exec_ctx, p->base.interested_parties, + pp->pollset); + grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, true, NULL); + gpr_free(pp); + pp = next; + } +} + +static void pf_cancel_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol, + grpc_connected_subchannel **target) { + pick_first_lb_policy *p = (pick_first_lb_policy *)pol; + pending_pick *pp; + gpr_mu_lock(&p->mu); + pp = p->pending_picks; + p->pending_picks = NULL; + while (pp != NULL) { + pending_pick *next = pp->next; + if (pp->target == target) { + grpc_pollset_set_del_pollset(exec_ctx, p->base.interested_parties, + pp->pollset); + *target = NULL; + grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, false, NULL); + gpr_free(pp); + } else { + pp->next = p->pending_picks; + p->pending_picks = pp; + } + pp = next; + } + gpr_mu_unlock(&p->mu); +} + +static void start_picking(grpc_exec_ctx *exec_ctx, pick_first_lb_policy *p) { + p->started_picking = 1; + p->checking_subchannel = 0; + p->checking_connectivity = GRPC_CHANNEL_IDLE; + GRPC_LB_POLICY_WEAK_REF(&p->base, "pick_first_connectivity"); + grpc_subchannel_notify_on_state_change( + exec_ctx, p->subchannels[p->checking_subchannel], + p->base.interested_parties, &p->checking_connectivity, + &p->connectivity_changed); +} + +void pf_exit_idle(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) { + pick_first_lb_policy *p = (pick_first_lb_policy *)pol; + gpr_mu_lock(&p->mu); + if (!p->started_picking) { + start_picking(exec_ctx, p); + } + gpr_mu_unlock(&p->mu); +} + +int pf_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol, grpc_pollset *pollset, + grpc_metadata_batch *initial_metadata, + grpc_connected_subchannel **target, grpc_closure *on_complete) { + pick_first_lb_policy *p = (pick_first_lb_policy *)pol; + pending_pick *pp; + + /* Check atomically for a selected channel */ + grpc_connected_subchannel *selected = GET_SELECTED(p); + if (selected != NULL) { + *target = selected; + return 1; + } + + /* No subchannel selected yet, so acquire lock and then attempt again */ + gpr_mu_lock(&p->mu); + selected = GET_SELECTED(p); + if (selected) { + gpr_mu_unlock(&p->mu); + *target = selected; + return 1; + } else { + if (!p->started_picking) { + start_picking(exec_ctx, p); + } + grpc_pollset_set_add_pollset(exec_ctx, p->base.interested_parties, pollset); + pp = gpr_malloc(sizeof(*pp)); + pp->next = p->pending_picks; + pp->pollset = pollset; + pp->target = target; + pp->on_complete = on_complete; + p->pending_picks = pp; + gpr_mu_unlock(&p->mu); + return 0; + } +} + +static void destroy_subchannels(grpc_exec_ctx *exec_ctx, void *arg, + bool iomgr_success) { + pick_first_lb_policy *p = arg; + size_t i; + size_t num_subchannels = p->num_subchannels; + grpc_subchannel **subchannels; + + gpr_mu_lock(&p->mu); + subchannels = p->subchannels; + p->num_subchannels = 0; + p->subchannels = NULL; + gpr_mu_unlock(&p->mu); + GRPC_LB_POLICY_WEAK_UNREF(exec_ctx, &p->base, "destroy_subchannels"); + + for (i = 0; i < num_subchannels; i++) { + GRPC_SUBCHANNEL_UNREF(exec_ctx, subchannels[i], "pick_first"); + } + + gpr_free(subchannels); +} + +static void pf_connectivity_changed(grpc_exec_ctx *exec_ctx, void *arg, + bool iomgr_success) { + pick_first_lb_policy *p = arg; + grpc_subchannel *selected_subchannel; + pending_pick *pp; + grpc_connected_subchannel *selected; + + gpr_mu_lock(&p->mu); + + selected = GET_SELECTED(p); + + if (p->shutdown) { + gpr_mu_unlock(&p->mu); + GRPC_LB_POLICY_WEAK_UNREF(exec_ctx, &p->base, "pick_first_connectivity"); + return; + } else if (selected != NULL) { + if (p->checking_connectivity == GRPC_CHANNEL_TRANSIENT_FAILURE) { + /* if the selected channel goes bad, we're done */ + p->checking_connectivity = GRPC_CHANNEL_FATAL_FAILURE; + } + grpc_connectivity_state_set(exec_ctx, &p->state_tracker, + p->checking_connectivity, "selected_changed"); + if (p->checking_connectivity != GRPC_CHANNEL_FATAL_FAILURE) { + grpc_connected_subchannel_notify_on_state_change( + exec_ctx, selected, p->base.interested_parties, + &p->checking_connectivity, &p->connectivity_changed); + } else { + GRPC_LB_POLICY_WEAK_UNREF(exec_ctx, &p->base, "pick_first_connectivity"); + } + } else { + loop: + switch (p->checking_connectivity) { + case GRPC_CHANNEL_READY: + grpc_connectivity_state_set(exec_ctx, &p->state_tracker, + GRPC_CHANNEL_READY, "connecting_ready"); + selected_subchannel = p->subchannels[p->checking_subchannel]; + selected = + grpc_subchannel_get_connected_subchannel(selected_subchannel); + GPR_ASSERT(selected != NULL); + GRPC_CONNECTED_SUBCHANNEL_REF(selected, "picked_first"); + /* drop the pick list: we are connected now */ + GRPC_LB_POLICY_WEAK_REF(&p->base, "destroy_subchannels"); + gpr_atm_rel_store(&p->selected, (gpr_atm)selected); + grpc_exec_ctx_enqueue( + exec_ctx, grpc_closure_create(destroy_subchannels, p), true, NULL); + /* update any calls that were waiting for a pick */ + while ((pp = p->pending_picks)) { + p->pending_picks = pp->next; + *pp->target = selected; + grpc_pollset_set_del_pollset(exec_ctx, p->base.interested_parties, + pp->pollset); + grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, true, NULL); + gpr_free(pp); + } + grpc_connected_subchannel_notify_on_state_change( + exec_ctx, selected, p->base.interested_parties, + &p->checking_connectivity, &p->connectivity_changed); + break; + case GRPC_CHANNEL_TRANSIENT_FAILURE: + grpc_connectivity_state_set(exec_ctx, &p->state_tracker, + GRPC_CHANNEL_TRANSIENT_FAILURE, + "connecting_transient_failure"); + p->checking_subchannel = + (p->checking_subchannel + 1) % p->num_subchannels; + p->checking_connectivity = grpc_subchannel_check_connectivity( + p->subchannels[p->checking_subchannel]); + if (p->checking_connectivity == GRPC_CHANNEL_TRANSIENT_FAILURE) { + grpc_subchannel_notify_on_state_change( + exec_ctx, p->subchannels[p->checking_subchannel], + p->base.interested_parties, &p->checking_connectivity, + &p->connectivity_changed); + } else { + goto loop; + } + break; + case GRPC_CHANNEL_CONNECTING: + case GRPC_CHANNEL_IDLE: + grpc_connectivity_state_set(exec_ctx, &p->state_tracker, + GRPC_CHANNEL_CONNECTING, + "connecting_changed"); + grpc_subchannel_notify_on_state_change( + exec_ctx, p->subchannels[p->checking_subchannel], + p->base.interested_parties, &p->checking_connectivity, + &p->connectivity_changed); + break; + case GRPC_CHANNEL_FATAL_FAILURE: + p->num_subchannels--; + GPR_SWAP(grpc_subchannel *, p->subchannels[p->checking_subchannel], + p->subchannels[p->num_subchannels]); + GRPC_SUBCHANNEL_UNREF(exec_ctx, p->subchannels[p->num_subchannels], + "pick_first"); + if (p->num_subchannels == 0) { + grpc_connectivity_state_set(exec_ctx, &p->state_tracker, + GRPC_CHANNEL_FATAL_FAILURE, + "no_more_channels"); + while ((pp = p->pending_picks)) { + p->pending_picks = pp->next; + *pp->target = NULL; + grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, true, NULL); + gpr_free(pp); + } + GRPC_LB_POLICY_WEAK_UNREF(exec_ctx, &p->base, + "pick_first_connectivity"); + } else { + grpc_connectivity_state_set(exec_ctx, &p->state_tracker, + GRPC_CHANNEL_TRANSIENT_FAILURE, + "subchannel_failed"); + p->checking_subchannel %= p->num_subchannels; + p->checking_connectivity = grpc_subchannel_check_connectivity( + p->subchannels[p->checking_subchannel]); + goto loop; + } + } + } + + gpr_mu_unlock(&p->mu); +} + +static grpc_connectivity_state pf_check_connectivity(grpc_exec_ctx *exec_ctx, + grpc_lb_policy *pol) { + pick_first_lb_policy *p = (pick_first_lb_policy *)pol; + grpc_connectivity_state st; + gpr_mu_lock(&p->mu); + st = grpc_connectivity_state_check(&p->state_tracker); + gpr_mu_unlock(&p->mu); + return st; +} + +void pf_notify_on_state_change(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol, + grpc_connectivity_state *current, + grpc_closure *notify) { + pick_first_lb_policy *p = (pick_first_lb_policy *)pol; + gpr_mu_lock(&p->mu); + grpc_connectivity_state_notify_on_state_change(exec_ctx, &p->state_tracker, + current, notify); + gpr_mu_unlock(&p->mu); +} + +void pf_ping_one(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol, + grpc_closure *closure) { + pick_first_lb_policy *p = (pick_first_lb_policy *)pol; + grpc_connected_subchannel *selected = GET_SELECTED(p); + if (selected) { + grpc_connected_subchannel_ping(exec_ctx, selected, closure); + } else { + grpc_exec_ctx_enqueue(exec_ctx, closure, false, NULL); + } +} + +static const grpc_lb_policy_vtable pick_first_lb_policy_vtable = { + pf_destroy, + pf_shutdown, + pf_pick, + pf_cancel_pick, + pf_ping_one, + pf_exit_idle, + pf_check_connectivity, + pf_notify_on_state_change}; + +static void pick_first_factory_ref(grpc_lb_policy_factory *factory) {} + +static void pick_first_factory_unref(grpc_lb_policy_factory *factory) {} + +static grpc_lb_policy *create_pick_first(grpc_lb_policy_factory *factory, + grpc_lb_policy_args *args) { + if (args->num_subchannels == 0) return NULL; + pick_first_lb_policy *p = gpr_malloc(sizeof(*p)); + memset(p, 0, sizeof(*p)); + grpc_lb_policy_init(&p->base, &pick_first_lb_policy_vtable); + p->subchannels = + gpr_malloc(sizeof(grpc_subchannel *) * args->num_subchannels); + p->num_subchannels = args->num_subchannels; + grpc_connectivity_state_init(&p->state_tracker, GRPC_CHANNEL_IDLE, + "pick_first"); + memcpy(p->subchannels, args->subchannels, + sizeof(grpc_subchannel *) * args->num_subchannels); + grpc_closure_init(&p->connectivity_changed, pf_connectivity_changed, p); + gpr_mu_init(&p->mu); + return &p->base; +} + +static const grpc_lb_policy_factory_vtable pick_first_factory_vtable = { + pick_first_factory_ref, pick_first_factory_unref, create_pick_first, + "pick_first"}; + +static grpc_lb_policy_factory pick_first_lb_policy_factory = { + &pick_first_factory_vtable}; + +grpc_lb_policy_factory *grpc_pick_first_lb_factory_create() { + return &pick_first_lb_policy_factory; +} diff --git a/src/core/lib/client_config/lb_policies/pick_first.h b/src/core/lib/client_config/lb_policies/pick_first.h new file mode 100644 index 0000000000..3a3f195df5 --- /dev/null +++ b/src/core/lib/client_config/lb_policies/pick_first.h @@ -0,0 +1,43 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_LB_POLICIES_PICK_FIRST_H +#define GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_PICK_FIRST_H + +#include "src/core/client_config/lb_policy_factory.h" + +/** Returns a load balancing factory for the pick first policy, which picks up + * the first subchannel from \a subchannels to succesfully connect */ +grpc_lb_policy_factory *grpc_pick_first_lb_factory_create(); + +#endif /* GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_PICK_FIRST_H */ diff --git a/src/core/lib/client_config/lb_policies/round_robin.c b/src/core/lib/client_config/lb_policies/round_robin.c new file mode 100644 index 0000000000..114ece6e4d --- /dev/null +++ b/src/core/lib/client_config/lb_policies/round_robin.c @@ -0,0 +1,542 @@ +/* + * + * Copyright 2015-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. + * + */ + +#include "src/core/client_config/lb_policies/round_robin.h" + +#include + +#include +#include "src/core/transport/connectivity_state.h" + +typedef struct round_robin_lb_policy round_robin_lb_policy; + +int grpc_lb_round_robin_trace = 0; + +/** List of entities waiting for a pick. + * + * Once a pick is available, \a target is updated and \a on_complete called. */ +typedef struct pending_pick { + struct pending_pick *next; + grpc_pollset *pollset; + grpc_connected_subchannel **target; + grpc_closure *on_complete; +} pending_pick; + +/** List of subchannels in a connectivity READY state */ +typedef struct ready_list { + grpc_subchannel *subchannel; + struct ready_list *next; + struct ready_list *prev; +} ready_list; + +typedef struct { + /** index within policy->subchannels */ + size_t index; + /** backpointer to owning policy */ + round_robin_lb_policy *policy; + /** subchannel itself */ + grpc_subchannel *subchannel; + /** notification that connectivity has changed on subchannel */ + grpc_closure connectivity_changed_closure; + /** this subchannels current position in subchannel->ready_list */ + ready_list *ready_list_node; + /** last observed connectivity */ + grpc_connectivity_state connectivity_state; +} subchannel_data; + +struct round_robin_lb_policy { + /** base policy: must be first */ + grpc_lb_policy base; + + /** all our subchannels */ + size_t num_subchannels; + subchannel_data **subchannels; + + /** mutex protecting remaining members */ + gpr_mu mu; + /** have we started picking? */ + int started_picking; + /** are we shutting down? */ + int shutdown; + /** List of picks that are waiting on connectivity */ + pending_pick *pending_picks; + + /** our connectivity state tracker */ + grpc_connectivity_state_tracker state_tracker; + + /** (Dummy) root of the doubly linked list containing READY subchannels */ + ready_list ready_list; + /** Last pick from the ready list. */ + ready_list *ready_list_last_pick; +}; + +/** Returns the next subchannel from the connected list or NULL if the list is + * empty. + * + * Note that this function does *not* advance p->ready_list_last_pick. Use \a + * advance_last_picked_locked() for that. */ +static ready_list *peek_next_connected_locked(const round_robin_lb_policy *p) { + ready_list *selected; + selected = p->ready_list_last_pick->next; + + while (selected != NULL) { + if (selected == &p->ready_list) { + GPR_ASSERT(selected->subchannel == NULL); + /* skip dummy root */ + selected = selected->next; + } else { + GPR_ASSERT(selected->subchannel != NULL); + return selected; + } + } + return NULL; +} + +/** Advance the \a ready_list picking head. */ +static void advance_last_picked_locked(round_robin_lb_policy *p) { + if (p->ready_list_last_pick->next != NULL) { /* non-empty list */ + p->ready_list_last_pick = p->ready_list_last_pick->next; + if (p->ready_list_last_pick == &p->ready_list) { + /* skip dummy root */ + p->ready_list_last_pick = p->ready_list_last_pick->next; + } + } else { /* should be an empty list */ + GPR_ASSERT(p->ready_list_last_pick == &p->ready_list); + } + + if (grpc_lb_round_robin_trace) { + gpr_log(GPR_DEBUG, "[READYLIST] ADVANCED LAST PICK. NOW AT NODE %p (SC %p)", + p->ready_list_last_pick, p->ready_list_last_pick->subchannel); + } +} + +/** Prepends (relative to the root at p->ready_list) the connected subchannel \a + * csc to the list of ready subchannels. */ +static ready_list *add_connected_sc_locked(round_robin_lb_policy *p, + grpc_subchannel *sc) { + ready_list *new_elem = gpr_malloc(sizeof(ready_list)); + new_elem->subchannel = sc; + if (p->ready_list.prev == NULL) { + /* first element */ + new_elem->next = &p->ready_list; + new_elem->prev = &p->ready_list; + p->ready_list.next = new_elem; + p->ready_list.prev = new_elem; + } else { + new_elem->next = &p->ready_list; + new_elem->prev = p->ready_list.prev; + p->ready_list.prev->next = new_elem; + p->ready_list.prev = new_elem; + } + if (grpc_lb_round_robin_trace) { + gpr_log(GPR_DEBUG, "[READYLIST] ADDING NODE %p (SC %p)", new_elem, sc); + } + return new_elem; +} + +/** Removes \a node from the list of connected subchannels */ +static void remove_disconnected_sc_locked(round_robin_lb_policy *p, + ready_list *node) { + if (node == NULL) { + return; + } + if (node == p->ready_list_last_pick) { + /* If removing the lastly picked node, reset the last pick pointer to the + * dummy root of the list */ + p->ready_list_last_pick = &p->ready_list; + } + + /* removing last item */ + if (node->next == &p->ready_list && node->prev == &p->ready_list) { + GPR_ASSERT(p->ready_list.next == node); + GPR_ASSERT(p->ready_list.prev == node); + p->ready_list.next = NULL; + p->ready_list.prev = NULL; + } else { + node->prev->next = node->next; + node->next->prev = node->prev; + } + + if (grpc_lb_round_robin_trace) { + gpr_log(GPR_DEBUG, "[READYLIST] REMOVED NODE %p (SC %p)", node, + node->subchannel); + } + + node->next = NULL; + node->prev = NULL; + node->subchannel = NULL; + + gpr_free(node); +} + +void rr_destroy(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) { + round_robin_lb_policy *p = (round_robin_lb_policy *)pol; + size_t i; + ready_list *elem; + for (i = 0; i < p->num_subchannels; i++) { + subchannel_data *sd = p->subchannels[i]; + GRPC_SUBCHANNEL_UNREF(exec_ctx, sd->subchannel, "round_robin"); + gpr_free(sd); + } + + grpc_connectivity_state_destroy(exec_ctx, &p->state_tracker); + gpr_free(p->subchannels); + gpr_mu_destroy(&p->mu); + + elem = p->ready_list.next; + while (elem != NULL && elem != &p->ready_list) { + ready_list *tmp; + tmp = elem->next; + elem->next = NULL; + elem->prev = NULL; + elem->subchannel = NULL; + gpr_free(elem); + elem = tmp; + } + gpr_free(p); +} + +void rr_shutdown(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) { + round_robin_lb_policy *p = (round_robin_lb_policy *)pol; + pending_pick *pp; + size_t i; + + gpr_mu_lock(&p->mu); + + p->shutdown = 1; + while ((pp = p->pending_picks)) { + p->pending_picks = pp->next; + *pp->target = NULL; + grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, false, NULL); + gpr_free(pp); + } + grpc_connectivity_state_set(exec_ctx, &p->state_tracker, + GRPC_CHANNEL_FATAL_FAILURE, "shutdown"); + for (i = 0; i < p->num_subchannels; i++) { + subchannel_data *sd = p->subchannels[i]; + grpc_subchannel_notify_on_state_change(exec_ctx, sd->subchannel, NULL, NULL, + &sd->connectivity_changed_closure); + } + gpr_mu_unlock(&p->mu); +} + +static void rr_cancel_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol, + grpc_connected_subchannel **target) { + round_robin_lb_policy *p = (round_robin_lb_policy *)pol; + pending_pick *pp; + gpr_mu_lock(&p->mu); + pp = p->pending_picks; + p->pending_picks = NULL; + while (pp != NULL) { + pending_pick *next = pp->next; + if (pp->target == target) { + grpc_pollset_set_del_pollset(exec_ctx, p->base.interested_parties, + pp->pollset); + *target = NULL; + grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, false, NULL); + gpr_free(pp); + } else { + pp->next = p->pending_picks; + p->pending_picks = pp; + } + pp = next; + } + gpr_mu_unlock(&p->mu); +} + +static void start_picking(grpc_exec_ctx *exec_ctx, round_robin_lb_policy *p) { + size_t i; + p->started_picking = 1; + + gpr_log(GPR_DEBUG, "LB_POLICY: p=%p num_subchannels=%d", p, + p->num_subchannels); + + for (i = 0; i < p->num_subchannels; i++) { + subchannel_data *sd = p->subchannels[i]; + sd->connectivity_state = GRPC_CHANNEL_IDLE; + grpc_subchannel_notify_on_state_change( + exec_ctx, sd->subchannel, p->base.interested_parties, + &sd->connectivity_state, &sd->connectivity_changed_closure); + GRPC_LB_POLICY_WEAK_REF(&p->base, "round_robin_connectivity"); + } +} + +void rr_exit_idle(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) { + round_robin_lb_policy *p = (round_robin_lb_policy *)pol; + gpr_mu_lock(&p->mu); + if (!p->started_picking) { + start_picking(exec_ctx, p); + } + gpr_mu_unlock(&p->mu); +} + +int rr_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol, grpc_pollset *pollset, + grpc_metadata_batch *initial_metadata, + grpc_connected_subchannel **target, grpc_closure *on_complete) { + round_robin_lb_policy *p = (round_robin_lb_policy *)pol; + pending_pick *pp; + ready_list *selected; + gpr_mu_lock(&p->mu); + if ((selected = peek_next_connected_locked(p))) { + gpr_mu_unlock(&p->mu); + *target = grpc_subchannel_get_connected_subchannel(selected->subchannel); + if (grpc_lb_round_robin_trace) { + gpr_log(GPR_DEBUG, + "[RR PICK] TARGET <-- CONNECTED SUBCHANNEL %p (NODE %p)", + selected->subchannel, selected); + } + /* only advance the last picked pointer if the selection was used */ + advance_last_picked_locked(p); + return 1; + } else { + if (!p->started_picking) { + start_picking(exec_ctx, p); + } + grpc_pollset_set_add_pollset(exec_ctx, p->base.interested_parties, pollset); + pp = gpr_malloc(sizeof(*pp)); + pp->next = p->pending_picks; + pp->pollset = pollset; + pp->target = target; + pp->on_complete = on_complete; + p->pending_picks = pp; + gpr_mu_unlock(&p->mu); + return 0; + } +} + +static void rr_connectivity_changed(grpc_exec_ctx *exec_ctx, void *arg, + bool iomgr_success) { + subchannel_data *sd = arg; + round_robin_lb_policy *p = sd->policy; + pending_pick *pp; + ready_list *selected; + + int unref = 0; + + gpr_mu_lock(&p->mu); + + if (p->shutdown) { + unref = 1; + } else { + switch (sd->connectivity_state) { + case GRPC_CHANNEL_READY: + grpc_connectivity_state_set(exec_ctx, &p->state_tracker, + GRPC_CHANNEL_READY, "connecting_ready"); + /* add the newly connected subchannel to the list of connected ones. + * Note that it goes to the "end of the line". */ + sd->ready_list_node = add_connected_sc_locked(p, sd->subchannel); + /* at this point we know there's at least one suitable subchannel. Go + * ahead and pick one and notify the pending suitors in + * p->pending_picks. This preemtively replicates rr_pick()'s actions. */ + selected = peek_next_connected_locked(p); + if (p->pending_picks != NULL) { + /* if the selected subchannel is going to be used for the pending + * picks, update the last picked pointer */ + advance_last_picked_locked(p); + } + while ((pp = p->pending_picks)) { + p->pending_picks = pp->next; + *pp->target = + grpc_subchannel_get_connected_subchannel(selected->subchannel); + if (grpc_lb_round_robin_trace) { + gpr_log(GPR_DEBUG, + "[RR CONN CHANGED] TARGET <-- SUBCHANNEL %p (NODE %p)", + selected->subchannel, selected); + } + grpc_pollset_set_del_pollset(exec_ctx, p->base.interested_parties, + pp->pollset); + grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, true, NULL); + gpr_free(pp); + } + grpc_subchannel_notify_on_state_change( + exec_ctx, sd->subchannel, p->base.interested_parties, + &sd->connectivity_state, &sd->connectivity_changed_closure); + break; + case GRPC_CHANNEL_CONNECTING: + case GRPC_CHANNEL_IDLE: + grpc_connectivity_state_set(exec_ctx, &p->state_tracker, + sd->connectivity_state, + "connecting_changed"); + grpc_subchannel_notify_on_state_change( + exec_ctx, sd->subchannel, p->base.interested_parties, + &sd->connectivity_state, &sd->connectivity_changed_closure); + break; + case GRPC_CHANNEL_TRANSIENT_FAILURE: + /* renew state notification */ + grpc_subchannel_notify_on_state_change( + exec_ctx, sd->subchannel, p->base.interested_parties, + &sd->connectivity_state, &sd->connectivity_changed_closure); + + /* remove from ready list if still present */ + if (sd->ready_list_node != NULL) { + remove_disconnected_sc_locked(p, sd->ready_list_node); + sd->ready_list_node = NULL; + } + grpc_connectivity_state_set(exec_ctx, &p->state_tracker, + GRPC_CHANNEL_TRANSIENT_FAILURE, + "connecting_transient_failure"); + break; + case GRPC_CHANNEL_FATAL_FAILURE: + if (sd->ready_list_node != NULL) { + remove_disconnected_sc_locked(p, sd->ready_list_node); + sd->ready_list_node = NULL; + } + + p->num_subchannels--; + GPR_SWAP(subchannel_data *, p->subchannels[sd->index], + p->subchannels[p->num_subchannels]); + GRPC_SUBCHANNEL_UNREF(exec_ctx, sd->subchannel, "round_robin"); + p->subchannels[sd->index]->index = sd->index; + gpr_free(sd); + + unref = 1; + if (p->num_subchannels == 0) { + grpc_connectivity_state_set(exec_ctx, &p->state_tracker, + GRPC_CHANNEL_FATAL_FAILURE, + "no_more_channels"); + while ((pp = p->pending_picks)) { + p->pending_picks = pp->next; + *pp->target = NULL; + grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, true, NULL); + gpr_free(pp); + } + } else { + grpc_connectivity_state_set(exec_ctx, &p->state_tracker, + GRPC_CHANNEL_TRANSIENT_FAILURE, + "subchannel_failed"); + } + } /* switch */ + } /* !unref */ + + gpr_mu_unlock(&p->mu); + + if (unref) { + GRPC_LB_POLICY_WEAK_UNREF(exec_ctx, &p->base, "round_robin_connectivity"); + } +} + +static grpc_connectivity_state rr_check_connectivity(grpc_exec_ctx *exec_ctx, + grpc_lb_policy *pol) { + round_robin_lb_policy *p = (round_robin_lb_policy *)pol; + grpc_connectivity_state st; + gpr_mu_lock(&p->mu); + st = grpc_connectivity_state_check(&p->state_tracker); + gpr_mu_unlock(&p->mu); + return st; +} + +static void rr_notify_on_state_change(grpc_exec_ctx *exec_ctx, + grpc_lb_policy *pol, + grpc_connectivity_state *current, + grpc_closure *notify) { + round_robin_lb_policy *p = (round_robin_lb_policy *)pol; + gpr_mu_lock(&p->mu); + grpc_connectivity_state_notify_on_state_change(exec_ctx, &p->state_tracker, + current, notify); + gpr_mu_unlock(&p->mu); +} + +static void rr_ping_one(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol, + grpc_closure *closure) { + round_robin_lb_policy *p = (round_robin_lb_policy *)pol; + ready_list *selected; + grpc_connected_subchannel *target; + gpr_mu_lock(&p->mu); + if ((selected = peek_next_connected_locked(p))) { + gpr_mu_unlock(&p->mu); + target = grpc_subchannel_get_connected_subchannel(selected->subchannel); + grpc_connected_subchannel_ping(exec_ctx, target, closure); + } else { + gpr_mu_unlock(&p->mu); + grpc_exec_ctx_enqueue(exec_ctx, closure, false, NULL); + } +} + +static const grpc_lb_policy_vtable round_robin_lb_policy_vtable = { + rr_destroy, + rr_shutdown, + rr_pick, + rr_cancel_pick, + rr_ping_one, + rr_exit_idle, + rr_check_connectivity, + rr_notify_on_state_change}; + +static void round_robin_factory_ref(grpc_lb_policy_factory *factory) {} + +static void round_robin_factory_unref(grpc_lb_policy_factory *factory) {} + +static grpc_lb_policy *create_round_robin(grpc_lb_policy_factory *factory, + grpc_lb_policy_args *args) { + size_t i; + round_robin_lb_policy *p = gpr_malloc(sizeof(*p)); + GPR_ASSERT(args->num_subchannels > 0); + memset(p, 0, sizeof(*p)); + grpc_lb_policy_init(&p->base, &round_robin_lb_policy_vtable); + p->num_subchannels = args->num_subchannels; + p->subchannels = gpr_malloc(sizeof(*p->subchannels) * p->num_subchannels); + memset(p->subchannels, 0, sizeof(*p->subchannels) * p->num_subchannels); + grpc_connectivity_state_init(&p->state_tracker, GRPC_CHANNEL_IDLE, + "round_robin"); + + gpr_mu_init(&p->mu); + for (i = 0; i < args->num_subchannels; i++) { + subchannel_data *sd = gpr_malloc(sizeof(*sd)); + memset(sd, 0, sizeof(*sd)); + p->subchannels[i] = sd; + sd->policy = p; + sd->index = i; + sd->subchannel = args->subchannels[i]; + grpc_closure_init(&sd->connectivity_changed_closure, + rr_connectivity_changed, sd); + } + + /* The (dummy node) root of the ready list */ + p->ready_list.subchannel = NULL; + p->ready_list.prev = NULL; + p->ready_list.next = NULL; + p->ready_list_last_pick = &p->ready_list; + + return &p->base; +} + +static const grpc_lb_policy_factory_vtable round_robin_factory_vtable = { + round_robin_factory_ref, round_robin_factory_unref, create_round_robin, + "round_robin"}; + +static grpc_lb_policy_factory round_robin_lb_policy_factory = { + &round_robin_factory_vtable}; + +grpc_lb_policy_factory *grpc_round_robin_lb_factory_create() { + return &round_robin_lb_policy_factory; +} diff --git a/src/core/lib/client_config/lb_policies/round_robin.h b/src/core/lib/client_config/lb_policies/round_robin.h new file mode 100644 index 0000000000..7e6f1769e4 --- /dev/null +++ b/src/core/lib/client_config/lb_policies/round_robin.h @@ -0,0 +1,46 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_LB_POLICIES_ROUND_ROBIN_H +#define GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_ROUND_ROBIN_H + +#include "src/core/client_config/lb_policy.h" + +extern int grpc_lb_round_robin_trace; + +#include "src/core/client_config/lb_policy_factory.h" + +/** Returns a load balancing factory for the round robin policy */ +grpc_lb_policy_factory *grpc_round_robin_lb_factory_create(); + +#endif /* GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_ROUND_ROBIN_H */ diff --git a/src/core/lib/client_config/lb_policy.c b/src/core/lib/client_config/lb_policy.c new file mode 100644 index 0000000000..0d8b007336 --- /dev/null +++ b/src/core/lib/client_config/lb_policy.c @@ -0,0 +1,134 @@ +/* + * + * Copyright 2015-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. + * + */ + +#include "src/core/client_config/lb_policy.h" + +#define WEAK_REF_BITS 16 + +void grpc_lb_policy_init(grpc_lb_policy *policy, + const grpc_lb_policy_vtable *vtable) { + policy->vtable = vtable; + gpr_atm_no_barrier_store(&policy->ref_pair, 1 << WEAK_REF_BITS); + policy->interested_parties = grpc_pollset_set_create(); +} + +#ifdef GRPC_LB_POLICY_REFCOUNT_DEBUG +#define REF_FUNC_EXTRA_ARGS , const char *file, int line, const char *reason +#define REF_MUTATE_EXTRA_ARGS REF_FUNC_EXTRA_ARGS, const char *purpose +#define REF_FUNC_PASS_ARGS(new_reason) , file, line, new_reason +#define REF_MUTATE_PASS_ARGS(purpose) , file, line, reason, purpose +#else +#define REF_FUNC_EXTRA_ARGS +#define REF_MUTATE_EXTRA_ARGS +#define REF_FUNC_PASS_ARGS(new_reason) +#define REF_MUTATE_PASS_ARGS(x) +#endif + +static gpr_atm ref_mutate(grpc_lb_policy *c, gpr_atm delta, + int barrier REF_MUTATE_EXTRA_ARGS) { + gpr_atm old_val = barrier ? gpr_atm_full_fetch_add(&c->ref_pair, delta) + : gpr_atm_no_barrier_fetch_add(&c->ref_pair, delta); +#ifdef GRPC_LB_POLICY_REFCOUNT_DEBUG + gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, + "LB_POLICY: %p % 12s 0x%08x -> 0x%08x [%s]", c, purpose, old_val, + old_val + delta, reason); +#endif + return old_val; +} + +void grpc_lb_policy_ref(grpc_lb_policy *policy REF_FUNC_EXTRA_ARGS) { + ref_mutate(policy, 1 << WEAK_REF_BITS, 0 REF_MUTATE_PASS_ARGS("STRONG_REF")); +} + +void grpc_lb_policy_unref(grpc_exec_ctx *exec_ctx, + grpc_lb_policy *policy REF_FUNC_EXTRA_ARGS) { + gpr_atm old_val = + ref_mutate(policy, (gpr_atm)1 - (gpr_atm)(1 << WEAK_REF_BITS), + 1 REF_MUTATE_PASS_ARGS("STRONG_UNREF")); + gpr_atm mask = ~(gpr_atm)((1 << WEAK_REF_BITS) - 1); + gpr_atm check = 1 << WEAK_REF_BITS; + if ((old_val & mask) == check) { + policy->vtable->shutdown(exec_ctx, policy); + } + grpc_lb_policy_weak_unref(exec_ctx, + policy REF_FUNC_PASS_ARGS("strong-unref")); +} + +void grpc_lb_policy_weak_ref(grpc_lb_policy *policy REF_FUNC_EXTRA_ARGS) { + ref_mutate(policy, 1, 0 REF_MUTATE_PASS_ARGS("WEAK_REF")); +} + +void grpc_lb_policy_weak_unref(grpc_exec_ctx *exec_ctx, + grpc_lb_policy *policy REF_FUNC_EXTRA_ARGS) { + gpr_atm old_val = + ref_mutate(policy, -(gpr_atm)1, 1 REF_MUTATE_PASS_ARGS("WEAK_UNREF")); + if (old_val == 1) { + grpc_pollset_set_destroy(policy->interested_parties); + policy->vtable->destroy(exec_ctx, policy); + } +} + +int grpc_lb_policy_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy, + grpc_pollset *pollset, + grpc_metadata_batch *initial_metadata, + grpc_connected_subchannel **target, + grpc_closure *on_complete) { + return policy->vtable->pick(exec_ctx, policy, pollset, initial_metadata, + target, on_complete); +} + +void grpc_lb_policy_cancel_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy, + grpc_connected_subchannel **target) { + policy->vtable->cancel_pick(exec_ctx, policy, target); +} + +void grpc_lb_policy_exit_idle(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy) { + policy->vtable->exit_idle(exec_ctx, policy); +} + +void grpc_lb_policy_ping_one(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy, + grpc_closure *closure) { + policy->vtable->ping_one(exec_ctx, policy, closure); +} + +void grpc_lb_policy_notify_on_state_change(grpc_exec_ctx *exec_ctx, + grpc_lb_policy *policy, + grpc_connectivity_state *state, + grpc_closure *closure) { + policy->vtable->notify_on_state_change(exec_ctx, policy, state, closure); +} + +grpc_connectivity_state grpc_lb_policy_check_connectivity( + grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy) { + return policy->vtable->check_connectivity(exec_ctx, policy); +} diff --git a/src/core/lib/client_config/lb_policy.h b/src/core/lib/client_config/lb_policy.h new file mode 100644 index 0000000000..ffebc2a69c --- /dev/null +++ b/src/core/lib/client_config/lb_policy.h @@ -0,0 +1,144 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_LB_POLICY_H +#define GRPC_CORE_CLIENT_CONFIG_LB_POLICY_H + +#include "src/core/client_config/subchannel.h" +#include "src/core/transport/connectivity_state.h" + +/** A load balancing policy: specified by a vtable and a struct (which + is expected to be extended to contain some parameters) */ +typedef struct grpc_lb_policy grpc_lb_policy; +typedef struct grpc_lb_policy_vtable grpc_lb_policy_vtable; + +typedef void (*grpc_lb_completion)(void *cb_arg, grpc_subchannel *subchannel, + grpc_status_code status, const char *errmsg); + +struct grpc_lb_policy { + const grpc_lb_policy_vtable *vtable; + gpr_atm ref_pair; + /* owned pointer to interested parties in load balancing decisions */ + grpc_pollset_set *interested_parties; +}; + +struct grpc_lb_policy_vtable { + void (*destroy)(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy); + + void (*shutdown)(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy); + + /** implement grpc_lb_policy_pick */ + int (*pick)(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy, + grpc_pollset *pollset, grpc_metadata_batch *initial_metadata, + grpc_connected_subchannel **target, grpc_closure *on_complete); + void (*cancel_pick)(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy, + grpc_connected_subchannel **target); + + void (*ping_one)(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy, + grpc_closure *closure); + + /** try to enter a READY connectivity state */ + void (*exit_idle)(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy); + + /** check the current connectivity of the lb_policy */ + grpc_connectivity_state (*check_connectivity)(grpc_exec_ctx *exec_ctx, + grpc_lb_policy *policy); + + /** call notify when the connectivity state of a channel changes from *state. + Updates *state with the new state of the policy */ + void (*notify_on_state_change)(grpc_exec_ctx *exec_ctx, + grpc_lb_policy *policy, + grpc_connectivity_state *state, + grpc_closure *closure); +}; + +/*#define GRPC_LB_POLICY_REFCOUNT_DEBUG*/ +#ifdef GRPC_LB_POLICY_REFCOUNT_DEBUG +#define GRPC_LB_POLICY_REF(p, r) \ + grpc_lb_policy_ref((p), __FILE__, __LINE__, (r)) +#define GRPC_LB_POLICY_UNREF(exec_ctx, p, r) \ + grpc_lb_policy_unref((exec_ctx), (p), __FILE__, __LINE__, (r)) +#define GRPC_LB_POLICY_WEAK_REF(p, r) \ + grpc_lb_policy_weak_ref((p), __FILE__, __LINE__, (r)) +#define GRPC_LB_POLICY_WEAK_UNREF(exec_ctx, p, r) \ + grpc_lb_policy_weak_unref((exec_ctx), (p), __FILE__, __LINE__, (r)) +void grpc_lb_policy_ref(grpc_lb_policy *policy, const char *file, int line, + const char *reason); +void grpc_lb_policy_unref(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy, + const char *file, int line, const char *reason); +void grpc_lb_policy_weak_ref(grpc_lb_policy *policy, const char *file, int line, + const char *reason); +void grpc_lb_policy_weak_unref(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy, + const char *file, int line, const char *reason); +#else +#define GRPC_LB_POLICY_REF(p, r) grpc_lb_policy_ref((p)) +#define GRPC_LB_POLICY_UNREF(cl, p, r) grpc_lb_policy_unref((cl), (p)) +#define GRPC_LB_POLICY_WEAK_REF(p, r) grpc_lb_policy_weak_ref((p)) +#define GRPC_LB_POLICY_WEAK_UNREF(cl, p, r) grpc_lb_policy_weak_unref((cl), (p)) +void grpc_lb_policy_ref(grpc_lb_policy *policy); +void grpc_lb_policy_unref(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy); +void grpc_lb_policy_weak_ref(grpc_lb_policy *policy); +void grpc_lb_policy_weak_unref(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy); +#endif + +/** called by concrete implementations to initialize the base struct */ +void grpc_lb_policy_init(grpc_lb_policy *policy, + const grpc_lb_policy_vtable *vtable); + +/** Given initial metadata in \a initial_metadata, find an appropriate + target for this rpc, and 'return' it by calling \a on_complete after setting + \a target. + Picking can be asynchronous. Any IO should be done under \a pollset. */ +int grpc_lb_policy_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy, + grpc_pollset *pollset, + grpc_metadata_batch *initial_metadata, + grpc_connected_subchannel **target, + grpc_closure *on_complete); + +void grpc_lb_policy_ping_one(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy, + grpc_closure *closure); + +void grpc_lb_policy_cancel_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy, + grpc_connected_subchannel **target); + +void grpc_lb_policy_exit_idle(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy); + +void grpc_lb_policy_notify_on_state_change(grpc_exec_ctx *exec_ctx, + grpc_lb_policy *policy, + grpc_connectivity_state *state, + grpc_closure *closure); + +grpc_connectivity_state grpc_lb_policy_check_connectivity( + grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy); + +#endif /* GRPC_CORE_CLIENT_CONFIG_LB_POLICY_H */ diff --git a/src/core/lib/client_config/lb_policy_factory.c b/src/core/lib/client_config/lb_policy_factory.c new file mode 100644 index 0000000000..e49de544e3 --- /dev/null +++ b/src/core/lib/client_config/lb_policy_factory.c @@ -0,0 +1,48 @@ +/* + * + * Copyright 2015, 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/client_config/lb_policy_factory.h" + +void grpc_lb_policy_factory_ref(grpc_lb_policy_factory* factory) { + factory->vtable->ref(factory); +} + +void grpc_lb_policy_factory_unref(grpc_lb_policy_factory* factory) { + factory->vtable->unref(factory); +} + +grpc_lb_policy* grpc_lb_policy_factory_create_lb_policy( + grpc_lb_policy_factory* factory, grpc_lb_policy_args* args) { + if (factory == NULL) return NULL; + return factory->vtable->create_lb_policy(factory, args); +} diff --git a/src/core/lib/client_config/lb_policy_factory.h b/src/core/lib/client_config/lb_policy_factory.h new file mode 100644 index 0000000000..842ba96098 --- /dev/null +++ b/src/core/lib/client_config/lb_policy_factory.h @@ -0,0 +1,73 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_LB_POLICY_FACTORY_H +#define GRPC_CORE_CLIENT_CONFIG_LB_POLICY_FACTORY_H + +#include "src/core/client_config/lb_policy.h" +#include "src/core/client_config/subchannel.h" + +typedef struct grpc_lb_policy_factory grpc_lb_policy_factory; +typedef struct grpc_lb_policy_factory_vtable grpc_lb_policy_factory_vtable; + +/** grpc_lb_policy provides grpc_client_config objects to grpc_channel + objects */ +struct grpc_lb_policy_factory { + const grpc_lb_policy_factory_vtable *vtable; +}; + +typedef struct grpc_lb_policy_args { + grpc_subchannel **subchannels; + size_t num_subchannels; +} grpc_lb_policy_args; + +struct grpc_lb_policy_factory_vtable { + void (*ref)(grpc_lb_policy_factory *factory); + void (*unref)(grpc_lb_policy_factory *factory); + + /** Implementation of grpc_lb_policy_factory_create_lb_policy */ + grpc_lb_policy *(*create_lb_policy)(grpc_lb_policy_factory *factory, + grpc_lb_policy_args *args); + + /** Name for the LB policy this factory implements */ + const char *name; +}; + +void grpc_lb_policy_factory_ref(grpc_lb_policy_factory *factory); +void grpc_lb_policy_factory_unref(grpc_lb_policy_factory *factory); + +/** Create a lb_policy instance. */ +grpc_lb_policy *grpc_lb_policy_factory_create_lb_policy( + grpc_lb_policy_factory *factory, grpc_lb_policy_args *args); + +#endif /* GRPC_CORE_CLIENT_CONFIG_LB_POLICY_FACTORY_H */ diff --git a/src/core/lib/client_config/lb_policy_registry.c b/src/core/lib/client_config/lb_policy_registry.c new file mode 100644 index 0000000000..fc302e82d7 --- /dev/null +++ b/src/core/lib/client_config/lb_policy_registry.c @@ -0,0 +1,88 @@ +/* + * + * Copyright 2015, 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/client_config/lb_policy_registry.h" + +#include + +#define MAX_POLICIES 10 + +static grpc_lb_policy_factory *g_all_of_the_lb_policies[MAX_POLICIES]; +static int g_number_of_lb_policies = 0; + +static grpc_lb_policy_factory *g_default_lb_policy_factory; + +void grpc_lb_policy_registry_init(grpc_lb_policy_factory *default_factory) { + g_number_of_lb_policies = 0; + g_default_lb_policy_factory = default_factory; +} + +void grpc_lb_policy_registry_shutdown(void) { + int i; + for (i = 0; i < g_number_of_lb_policies; i++) { + grpc_lb_policy_factory_unref(g_all_of_the_lb_policies[i]); + } +} + +void grpc_register_lb_policy(grpc_lb_policy_factory *factory) { + int i; + for (i = 0; i < g_number_of_lb_policies; i++) { + GPR_ASSERT(0 != strcmp(factory->vtable->name, + g_all_of_the_lb_policies[i]->vtable->name)); + } + GPR_ASSERT(g_number_of_lb_policies != MAX_POLICIES); + grpc_lb_policy_factory_ref(factory); + g_all_of_the_lb_policies[g_number_of_lb_policies++] = factory; +} + +static grpc_lb_policy_factory *lookup_factory(const char *name) { + int i; + + if (name == NULL) return NULL; + + for (i = 0; i < g_number_of_lb_policies; i++) { + if (0 == strcmp(name, g_all_of_the_lb_policies[i]->vtable->name)) { + return g_all_of_the_lb_policies[i]; + } + } + + return NULL; +} + +grpc_lb_policy *grpc_lb_policy_create(const char *name, + grpc_lb_policy_args *args) { + grpc_lb_policy_factory *factory = lookup_factory(name); + grpc_lb_policy *lb_policy = + grpc_lb_policy_factory_create_lb_policy(factory, args); + return lb_policy; +} diff --git a/src/core/lib/client_config/lb_policy_registry.h b/src/core/lib/client_config/lb_policy_registry.h new file mode 100644 index 0000000000..f3a08a3558 --- /dev/null +++ b/src/core/lib/client_config/lb_policy_registry.h @@ -0,0 +1,54 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_LB_POLICY_REGISTRY_H +#define GRPC_CORE_CLIENT_CONFIG_LB_POLICY_REGISTRY_H + +#include "src/core/client_config/lb_policy_factory.h" + +/** Initialize the registry and set \a default_factory as the factory to be + * returned when no name is provided in a lookup */ +void grpc_lb_policy_registry_init(grpc_lb_policy_factory *default_factory); +void grpc_lb_policy_registry_shutdown(void); + +/** Register a LB policy factory. */ +void grpc_register_lb_policy(grpc_lb_policy_factory *factory); + +/** Create a \a grpc_lb_policy instance. + * + * If \a name is NULL, the default factory from \a grpc_lb_policy_registry_init + * will be returned. */ +grpc_lb_policy *grpc_lb_policy_create(const char *name, + grpc_lb_policy_args *args); + +#endif /* GRPC_CORE_CLIENT_CONFIG_LB_POLICY_REGISTRY_H */ diff --git a/src/core/lib/client_config/resolver.c b/src/core/lib/client_config/resolver.c new file mode 100644 index 0000000000..eda01e72ba --- /dev/null +++ b/src/core/lib/client_config/resolver.c @@ -0,0 +1,82 @@ +/* + * + * Copyright 2015, 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/client_config/resolver.h" + +void grpc_resolver_init(grpc_resolver *resolver, + const grpc_resolver_vtable *vtable) { + resolver->vtable = vtable; + gpr_ref_init(&resolver->refs, 1); +} + +#ifdef GRPC_RESOLVER_REFCOUNT_DEBUG +void grpc_resolver_ref(grpc_resolver *resolver, grpc_closure_list *closure_list, + const char *file, int line, const char *reason) { + gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "RESOLVER:%p ref %d -> %d %s", + resolver, (int)resolver->refs.count, (int)resolver->refs.count + 1, + reason); +#else +void grpc_resolver_ref(grpc_resolver *resolver) { +#endif + gpr_ref(&resolver->refs); +} + +#ifdef GRPC_RESOLVER_REFCOUNT_DEBUG +void grpc_resolver_unref(grpc_resolver *resolver, + grpc_closure_list *closure_list, const char *file, + int line, const char *reason) { + gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "RESOLVER:%p unref %d -> %d %s", + resolver, (int)resolver->refs.count, (int)resolver->refs.count - 1, + reason); +#else +void grpc_resolver_unref(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver) { +#endif + if (gpr_unref(&resolver->refs)) { + resolver->vtable->destroy(exec_ctx, resolver); + } +} + +void grpc_resolver_shutdown(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver) { + resolver->vtable->shutdown(exec_ctx, resolver); +} + +void grpc_resolver_channel_saw_error(grpc_exec_ctx *exec_ctx, + grpc_resolver *resolver) { + resolver->vtable->channel_saw_error(exec_ctx, resolver); +} + +void grpc_resolver_next(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver, + grpc_client_config **target_config, + grpc_closure *on_complete) { + resolver->vtable->next(exec_ctx, resolver, target_config, on_complete); +} diff --git a/src/core/lib/client_config/resolver.h b/src/core/lib/client_config/resolver.h new file mode 100644 index 0000000000..96f88fef84 --- /dev/null +++ b/src/core/lib/client_config/resolver.h @@ -0,0 +1,94 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_RESOLVER_H +#define GRPC_CORE_CLIENT_CONFIG_RESOLVER_H + +#include "src/core/client_config/client_config.h" +#include "src/core/client_config/subchannel.h" +#include "src/core/iomgr/iomgr.h" + +typedef struct grpc_resolver grpc_resolver; +typedef struct grpc_resolver_vtable grpc_resolver_vtable; + +/** grpc_resolver provides grpc_client_config objects to grpc_channel + objects */ +struct grpc_resolver { + const grpc_resolver_vtable *vtable; + gpr_refcount refs; +}; + +struct grpc_resolver_vtable { + void (*destroy)(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver); + void (*shutdown)(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver); + void (*channel_saw_error)(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver); + void (*next)(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver, + grpc_client_config **target_config, grpc_closure *on_complete); +}; + +#ifdef GRPC_RESOLVER_REFCOUNT_DEBUG +#define GRPC_RESOLVER_REF(p, r) grpc_resolver_ref((p), __FILE__, __LINE__, (r)) +#define GRPC_RESOLVER_UNREF(cl, p, r) \ + grpc_resolver_unref((cl), (p), __FILE__, __LINE__, (r)) +void grpc_resolver_ref(grpc_resolver *policy, const char *file, int line, + const char *reason); +void grpc_resolver_unref(grpc_resolver *policy, grpc_closure_list *closure_list, + const char *file, int line, const char *reason); +#else +#define GRPC_RESOLVER_REF(p, r) grpc_resolver_ref((p)) +#define GRPC_RESOLVER_UNREF(cl, p, r) grpc_resolver_unref((cl), (p)) +void grpc_resolver_ref(grpc_resolver *policy); +void grpc_resolver_unref(grpc_exec_ctx *exec_ctx, grpc_resolver *policy); +#endif + +void grpc_resolver_init(grpc_resolver *resolver, + const grpc_resolver_vtable *vtable); + +void grpc_resolver_shutdown(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver); + +/** Notification that the channel has seen an error on some address. + Can be used as a hint that re-resolution is desirable soon. */ +void grpc_resolver_channel_saw_error(grpc_exec_ctx *exec_ctx, + grpc_resolver *resolver); + +/** Get the next client config. Called by the channel to fetch a new + configuration. Expected to set *target_config with a new configuration, + and then schedule on_complete for execution. + + If resolution is fatally broken, set *target_config to NULL and + schedule on_complete. */ +void grpc_resolver_next(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver, + grpc_client_config **target_config, + grpc_closure *on_complete); + +#endif /* GRPC_CORE_CLIENT_CONFIG_RESOLVER_H */ diff --git a/src/core/lib/client_config/resolver_factory.c b/src/core/lib/client_config/resolver_factory.c new file mode 100644 index 0000000000..e7e9196ac4 --- /dev/null +++ b/src/core/lib/client_config/resolver_factory.c @@ -0,0 +1,55 @@ +/* + * + * Copyright 2015, 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/client_config/resolver_factory.h" + +void grpc_resolver_factory_ref(grpc_resolver_factory* factory) { + factory->vtable->ref(factory); +} + +void grpc_resolver_factory_unref(grpc_resolver_factory* factory) { + factory->vtable->unref(factory); +} + +/** Create a resolver instance for a name */ +grpc_resolver* grpc_resolver_factory_create_resolver( + grpc_resolver_factory* factory, grpc_resolver_args* args) { + if (factory == NULL) return NULL; + return factory->vtable->create_resolver(factory, args); +} + +char* grpc_resolver_factory_get_default_authority( + grpc_resolver_factory* factory, grpc_uri* uri) { + if (factory == NULL) return NULL; + return factory->vtable->get_default_authority(factory, uri); +} diff --git a/src/core/lib/client_config/resolver_factory.h b/src/core/lib/client_config/resolver_factory.h new file mode 100644 index 0000000000..477f8db7f7 --- /dev/null +++ b/src/core/lib/client_config/resolver_factory.h @@ -0,0 +1,82 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_RESOLVER_FACTORY_H +#define GRPC_CORE_CLIENT_CONFIG_RESOLVER_FACTORY_H + +#include "src/core/client_config/resolver.h" +#include "src/core/client_config/subchannel_factory.h" +#include "src/core/client_config/uri_parser.h" + +typedef struct grpc_resolver_factory grpc_resolver_factory; +typedef struct grpc_resolver_factory_vtable grpc_resolver_factory_vtable; + +/** grpc_resolver provides grpc_client_config objects to grpc_channel + objects */ +struct grpc_resolver_factory { + const grpc_resolver_factory_vtable *vtable; +}; + +typedef struct grpc_resolver_args { + grpc_uri *uri; + grpc_subchannel_factory *subchannel_factory; +} grpc_resolver_args; + +struct grpc_resolver_factory_vtable { + void (*ref)(grpc_resolver_factory *factory); + void (*unref)(grpc_resolver_factory *factory); + + /** Implementation of grpc_resolver_factory_create_resolver */ + grpc_resolver *(*create_resolver)(grpc_resolver_factory *factory, + grpc_resolver_args *args); + + /** Implementation of grpc_resolver_factory_get_default_authority */ + char *(*get_default_authority)(grpc_resolver_factory *factory, grpc_uri *uri); + + /** URI scheme that this factory implements */ + const char *scheme; +}; + +void grpc_resolver_factory_ref(grpc_resolver_factory *resolver); +void grpc_resolver_factory_unref(grpc_resolver_factory *resolver); + +/** Create a resolver instance for a name */ +grpc_resolver *grpc_resolver_factory_create_resolver( + grpc_resolver_factory *factory, grpc_resolver_args *args); + +/** Return a (freshly allocated with gpr_malloc) string representing + the default authority to use for this scheme. */ +char *grpc_resolver_factory_get_default_authority( + grpc_resolver_factory *factory, grpc_uri *uri); + +#endif /* GRPC_CORE_CLIENT_CONFIG_RESOLVER_FACTORY_H */ diff --git a/src/core/lib/client_config/resolver_registry.c b/src/core/lib/client_config/resolver_registry.c new file mode 100644 index 0000000000..89a945c2d3 --- /dev/null +++ b/src/core/lib/client_config/resolver_registry.c @@ -0,0 +1,137 @@ +/* + * + * Copyright 2015, 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/client_config/resolver_registry.h" + +#include + +#include +#include +#include + +#define MAX_RESOLVERS 10 + +static grpc_resolver_factory *g_all_of_the_resolvers[MAX_RESOLVERS]; +static int g_number_of_resolvers = 0; + +static char *g_default_resolver_prefix; + +void grpc_resolver_registry_init(const char *default_resolver_prefix) { + g_number_of_resolvers = 0; + g_default_resolver_prefix = gpr_strdup(default_resolver_prefix); +} + +void grpc_resolver_registry_shutdown(void) { + int i; + for (i = 0; i < g_number_of_resolvers; i++) { + grpc_resolver_factory_unref(g_all_of_the_resolvers[i]); + } + gpr_free(g_default_resolver_prefix); +} + +void grpc_register_resolver_type(grpc_resolver_factory *factory) { + int i; + for (i = 0; i < g_number_of_resolvers; i++) { + GPR_ASSERT(0 != strcmp(factory->vtable->scheme, + g_all_of_the_resolvers[i]->vtable->scheme)); + } + GPR_ASSERT(g_number_of_resolvers != MAX_RESOLVERS); + grpc_resolver_factory_ref(factory); + g_all_of_the_resolvers[g_number_of_resolvers++] = factory; +} + +static grpc_resolver_factory *lookup_factory(grpc_uri *uri) { + int i; + + /* handling NULL uri's here simplifies grpc_resolver_create */ + if (!uri) return NULL; + + for (i = 0; i < g_number_of_resolvers; i++) { + if (0 == strcmp(uri->scheme, g_all_of_the_resolvers[i]->vtable->scheme)) { + return g_all_of_the_resolvers[i]; + } + } + + return NULL; +} + +static grpc_resolver_factory *resolve_factory(const char *target, + grpc_uri **uri) { + char *tmp; + grpc_resolver_factory *factory = NULL; + + GPR_ASSERT(uri != NULL); + *uri = grpc_uri_parse(target, 1); + factory = lookup_factory(*uri); + if (factory == NULL) { + if (g_default_resolver_prefix != NULL) { + grpc_uri_destroy(*uri); + gpr_asprintf(&tmp, "%s%s", g_default_resolver_prefix, target); + *uri = grpc_uri_parse(tmp, 1); + factory = lookup_factory(*uri); + if (factory == NULL) { + grpc_uri_destroy(grpc_uri_parse(target, 0)); + grpc_uri_destroy(grpc_uri_parse(tmp, 0)); + gpr_log(GPR_ERROR, "don't know how to resolve '%s' or '%s'", target, + tmp); + } + gpr_free(tmp); + } else { + grpc_uri_destroy(grpc_uri_parse(target, 0)); + gpr_log(GPR_ERROR, "don't know how to resolve '%s'", target); + } + } + return factory; +} + +grpc_resolver *grpc_resolver_create( + const char *target, grpc_subchannel_factory *subchannel_factory) { + grpc_uri *uri = NULL; + grpc_resolver_factory *factory = resolve_factory(target, &uri); + grpc_resolver *resolver; + grpc_resolver_args args; + memset(&args, 0, sizeof(args)); + args.uri = uri; + args.subchannel_factory = subchannel_factory; + resolver = grpc_resolver_factory_create_resolver(factory, &args); + grpc_uri_destroy(uri); + return resolver; +} + +char *grpc_get_default_authority(const char *target) { + grpc_uri *uri = NULL; + grpc_resolver_factory *factory = resolve_factory(target, &uri); + char *authority = grpc_resolver_factory_get_default_authority(factory, uri); + grpc_uri_destroy(uri); + return authority; +} diff --git a/src/core/lib/client_config/resolver_registry.h b/src/core/lib/client_config/resolver_registry.h new file mode 100644 index 0000000000..1e4cebee0b --- /dev/null +++ b/src/core/lib/client_config/resolver_registry.h @@ -0,0 +1,65 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_RESOLVER_REGISTRY_H +#define GRPC_CORE_CLIENT_CONFIG_RESOLVER_REGISTRY_H + +#include "src/core/client_config/resolver_factory.h" + +void grpc_resolver_registry_init(const char *default_prefix); +void grpc_resolver_registry_shutdown(void); + +/** Register a resolver type. + URI's of \a scheme will be resolved with the given resolver. + If \a priority is greater than zero, then the resolver will be eligible + to resolve names that are passed in with no scheme. Higher priority + resolvers will be tried before lower priority schemes. */ +void grpc_register_resolver_type(grpc_resolver_factory *factory); + +/** Create a resolver given \a target. + First tries to parse \a target as a URI. If this succeeds, tries + to locate a registered resolver factory based on the URI scheme. + If parsing or location fails, prefixes default_prefix from + grpc_resolver_registry_init to target, and tries again (if default_prefix + was not NULL). + If a resolver factory was found, use it to instantiate a resolver and + return it. + If a resolver factory was not found, return NULL. */ +grpc_resolver *grpc_resolver_create( + const char *target, grpc_subchannel_factory *subchannel_factory); + +/** Given a target, return a (freshly allocated with gpr_malloc) string + representing the default authority to pass from a client. */ +char *grpc_get_default_authority(const char *target); + +#endif /* GRPC_CORE_CLIENT_CONFIG_RESOLVER_REGISTRY_H */ diff --git a/src/core/lib/client_config/resolvers/dns_resolver.c b/src/core/lib/client_config/resolvers/dns_resolver.c new file mode 100644 index 0000000000..2b2ee97e12 --- /dev/null +++ b/src/core/lib/client_config/resolvers/dns_resolver.c @@ -0,0 +1,309 @@ +/* + * + * Copyright 2015-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. + * + */ + +#include "src/core/client_config/resolvers/dns_resolver.h" + +#include + +#include +#include +#include + +#include "src/core/client_config/lb_policy_registry.h" +#include "src/core/iomgr/resolve_address.h" +#include "src/core/iomgr/timer.h" +#include "src/core/support/backoff.h" +#include "src/core/support/string.h" + +#define BACKOFF_MULTIPLIER 1.6 +#define BACKOFF_JITTER 0.2 +#define BACKOFF_MIN_SECONDS 1 +#define BACKOFF_MAX_SECONDS 120 + +typedef struct { + /** base class: must be first */ + grpc_resolver base; + /** refcount */ + gpr_refcount refs; + /** name to resolve */ + char *name; + /** default port to use */ + char *default_port; + /** subchannel factory */ + grpc_subchannel_factory *subchannel_factory; + /** load balancing policy name */ + char *lb_policy_name; + + /** mutex guarding the rest of the state */ + gpr_mu mu; + /** are we currently resolving? */ + int resolving; + /** which version of resolved_config have we published? */ + int published_version; + /** which version of resolved_config is current? */ + int resolved_version; + /** pending next completion, or NULL */ + grpc_closure *next_completion; + /** target config address for next completion */ + grpc_client_config **target_config; + /** current (fully resolved) config */ + grpc_client_config *resolved_config; + /** retry timer */ + bool have_retry_timer; + grpc_timer retry_timer; + /** retry backoff state */ + gpr_backoff backoff_state; +} dns_resolver; + +static void dns_destroy(grpc_exec_ctx *exec_ctx, grpc_resolver *r); + +static void dns_start_resolving_locked(dns_resolver *r); +static void dns_maybe_finish_next_locked(grpc_exec_ctx *exec_ctx, + dns_resolver *r); + +static void dns_shutdown(grpc_exec_ctx *exec_ctx, grpc_resolver *r); +static void dns_channel_saw_error(grpc_exec_ctx *exec_ctx, grpc_resolver *r); +static void dns_next(grpc_exec_ctx *exec_ctx, grpc_resolver *r, + grpc_client_config **target_config, + grpc_closure *on_complete); + +static const grpc_resolver_vtable dns_resolver_vtable = { + dns_destroy, dns_shutdown, dns_channel_saw_error, dns_next}; + +static void dns_shutdown(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver) { + dns_resolver *r = (dns_resolver *)resolver; + gpr_mu_lock(&r->mu); + if (r->have_retry_timer) { + grpc_timer_cancel(exec_ctx, &r->retry_timer); + } + if (r->next_completion != NULL) { + *r->target_config = NULL; + grpc_exec_ctx_enqueue(exec_ctx, r->next_completion, true, NULL); + r->next_completion = NULL; + } + gpr_mu_unlock(&r->mu); +} + +static void dns_channel_saw_error(grpc_exec_ctx *exec_ctx, + grpc_resolver *resolver) { + dns_resolver *r = (dns_resolver *)resolver; + gpr_mu_lock(&r->mu); + if (!r->resolving) { + gpr_backoff_reset(&r->backoff_state); + dns_start_resolving_locked(r); + } + gpr_mu_unlock(&r->mu); +} + +static void dns_next(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver, + grpc_client_config **target_config, + grpc_closure *on_complete) { + dns_resolver *r = (dns_resolver *)resolver; + gpr_mu_lock(&r->mu); + GPR_ASSERT(!r->next_completion); + r->next_completion = on_complete; + r->target_config = target_config; + if (r->resolved_version == 0 && !r->resolving) { + gpr_backoff_reset(&r->backoff_state); + dns_start_resolving_locked(r); + } else { + dns_maybe_finish_next_locked(exec_ctx, r); + } + gpr_mu_unlock(&r->mu); +} + +static void dns_on_retry_timer(grpc_exec_ctx *exec_ctx, void *arg, + bool success) { + dns_resolver *r = arg; + + gpr_mu_lock(&r->mu); + r->have_retry_timer = false; + if (success) { + if (!r->resolving) { + dns_start_resolving_locked(r); + } + } + gpr_mu_unlock(&r->mu); + + GRPC_RESOLVER_UNREF(exec_ctx, &r->base, "retry-timer"); +} + +static void dns_on_resolved(grpc_exec_ctx *exec_ctx, void *arg, + grpc_resolved_addresses *addresses) { + dns_resolver *r = arg; + grpc_client_config *config = NULL; + grpc_subchannel **subchannels; + grpc_subchannel_args args; + grpc_lb_policy *lb_policy; + size_t i; + gpr_mu_lock(&r->mu); + GPR_ASSERT(r->resolving); + r->resolving = 0; + if (addresses != NULL) { + grpc_lb_policy_args lb_policy_args; + config = grpc_client_config_create(); + subchannels = gpr_malloc(sizeof(grpc_subchannel *) * addresses->naddrs); + size_t naddrs = 0; + for (i = 0; i < addresses->naddrs; i++) { + memset(&args, 0, sizeof(args)); + args.addr = (struct sockaddr *)(addresses->addrs[i].addr); + args.addr_len = (size_t)addresses->addrs[i].len; + grpc_subchannel *subchannel = grpc_subchannel_factory_create_subchannel( + exec_ctx, r->subchannel_factory, &args); + if (subchannel != NULL) { + subchannels[naddrs++] = subchannel; + } + } + memset(&lb_policy_args, 0, sizeof(lb_policy_args)); + lb_policy_args.subchannels = subchannels; + lb_policy_args.num_subchannels = naddrs; + lb_policy = grpc_lb_policy_create(r->lb_policy_name, &lb_policy_args); + if (lb_policy != NULL) { + grpc_client_config_set_lb_policy(config, lb_policy); + GRPC_LB_POLICY_UNREF(exec_ctx, lb_policy, "construction"); + } + grpc_resolved_addresses_destroy(addresses); + gpr_free(subchannels); + } else { + gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC); + gpr_timespec next_try = gpr_backoff_step(&r->backoff_state, now); + gpr_timespec timeout = gpr_time_sub(next_try, now); + gpr_log(GPR_DEBUG, "dns resolution failed: retrying in %d.%09d seconds", + timeout.tv_sec, timeout.tv_nsec); + GPR_ASSERT(!r->have_retry_timer); + r->have_retry_timer = true; + GRPC_RESOLVER_REF(&r->base, "retry-timer"); + grpc_timer_init(exec_ctx, &r->retry_timer, next_try, dns_on_retry_timer, r, + now); + } + if (r->resolved_config) { + grpc_client_config_unref(exec_ctx, r->resolved_config); + } + r->resolved_config = config; + r->resolved_version++; + dns_maybe_finish_next_locked(exec_ctx, r); + gpr_mu_unlock(&r->mu); + + GRPC_RESOLVER_UNREF(exec_ctx, &r->base, "dns-resolving"); +} + +static void dns_start_resolving_locked(dns_resolver *r) { + GRPC_RESOLVER_REF(&r->base, "dns-resolving"); + GPR_ASSERT(!r->resolving); + r->resolving = 1; + grpc_resolve_address(r->name, r->default_port, dns_on_resolved, r); +} + +static void dns_maybe_finish_next_locked(grpc_exec_ctx *exec_ctx, + dns_resolver *r) { + if (r->next_completion != NULL && + r->resolved_version != r->published_version) { + *r->target_config = r->resolved_config; + if (r->resolved_config) { + grpc_client_config_ref(r->resolved_config); + } + grpc_exec_ctx_enqueue(exec_ctx, r->next_completion, true, NULL); + r->next_completion = NULL; + r->published_version = r->resolved_version; + } +} + +static void dns_destroy(grpc_exec_ctx *exec_ctx, grpc_resolver *gr) { + dns_resolver *r = (dns_resolver *)gr; + gpr_mu_destroy(&r->mu); + if (r->resolved_config) { + grpc_client_config_unref(exec_ctx, r->resolved_config); + } + grpc_subchannel_factory_unref(exec_ctx, r->subchannel_factory); + gpr_free(r->name); + gpr_free(r->default_port); + gpr_free(r->lb_policy_name); + gpr_free(r); +} + +static grpc_resolver *dns_create(grpc_resolver_args *args, + const char *default_port, + const char *lb_policy_name) { + dns_resolver *r; + const char *path = args->uri->path; + + if (0 != strcmp(args->uri->authority, "")) { + gpr_log(GPR_ERROR, "authority based dns uri's not supported"); + return NULL; + } + + if (path[0] == '/') ++path; + + r = gpr_malloc(sizeof(dns_resolver)); + memset(r, 0, sizeof(*r)); + gpr_ref_init(&r->refs, 1); + gpr_mu_init(&r->mu); + grpc_resolver_init(&r->base, &dns_resolver_vtable); + r->name = gpr_strdup(path); + r->default_port = gpr_strdup(default_port); + r->subchannel_factory = args->subchannel_factory; + gpr_backoff_init(&r->backoff_state, BACKOFF_MULTIPLIER, BACKOFF_JITTER, + BACKOFF_MIN_SECONDS * 1000, BACKOFF_MAX_SECONDS * 1000); + grpc_subchannel_factory_ref(r->subchannel_factory); + r->lb_policy_name = gpr_strdup(lb_policy_name); + return &r->base; +} + +/* + * FACTORY + */ + +static void dns_factory_ref(grpc_resolver_factory *factory) {} + +static void dns_factory_unref(grpc_resolver_factory *factory) {} + +static grpc_resolver *dns_factory_create_resolver( + grpc_resolver_factory *factory, grpc_resolver_args *args) { + return dns_create(args, "https", "pick_first"); +} + +char *dns_factory_get_default_host_name(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 dns_factory_vtable = { + dns_factory_ref, dns_factory_unref, dns_factory_create_resolver, + dns_factory_get_default_host_name, "dns"}; +static grpc_resolver_factory dns_resolver_factory = {&dns_factory_vtable}; + +grpc_resolver_factory *grpc_dns_resolver_factory_create() { + return &dns_resolver_factory; +} diff --git a/src/core/lib/client_config/resolvers/dns_resolver.h b/src/core/lib/client_config/resolvers/dns_resolver.h new file mode 100644 index 0000000000..b24280b507 --- /dev/null +++ b/src/core/lib/client_config/resolvers/dns_resolver.h @@ -0,0 +1,42 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_RESOLVERS_DNS_RESOLVER_H +#define GRPC_CORE_CLIENT_CONFIG_RESOLVERS_DNS_RESOLVER_H + +#include "src/core/client_config/resolver_factory.h" + +/** Create a dns resolver factory */ +grpc_resolver_factory *grpc_dns_resolver_factory_create(void); + +#endif /* GRPC_CORE_CLIENT_CONFIG_RESOLVERS_DNS_RESOLVER_H */ diff --git a/src/core/lib/client_config/resolvers/sockaddr_resolver.c b/src/core/lib/client_config/resolvers/sockaddr_resolver.c new file mode 100644 index 0000000000..3cb7d79b67 --- /dev/null +++ b/src/core/lib/client_config/resolvers/sockaddr_resolver.c @@ -0,0 +1,372 @@ +/* + * + * Copyright 2015-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. + * + */ + +#include + +#include "src/core/client_config/resolvers/sockaddr_resolver.h" + +#include +#include + +#include +#include +#include + +#include "src/core/client_config/lb_policy_registry.h" +#include "src/core/iomgr/resolve_address.h" +#include "src/core/iomgr/unix_sockets_posix.h" +#include "src/core/support/string.h" + +typedef struct { + /** base class: must be first */ + grpc_resolver base; + /** refcount */ + gpr_refcount refs; + /** subchannel factory */ + grpc_subchannel_factory *subchannel_factory; + /** load balancing policy name */ + char *lb_policy_name; + + /** the addresses that we've 'resolved' */ + struct sockaddr_storage *addrs; + /** the corresponding length of the addresses */ + size_t *addrs_len; + /** how many elements in \a addrs */ + size_t num_addrs; + + /** mutex guarding the rest of the state */ + gpr_mu mu; + /** have we published? */ + int published; + /** pending next completion, or NULL */ + grpc_closure *next_completion; + /** target config address for next completion */ + grpc_client_config **target_config; +} sockaddr_resolver; + +static void sockaddr_destroy(grpc_exec_ctx *exec_ctx, grpc_resolver *r); + +static void sockaddr_maybe_finish_next_locked(grpc_exec_ctx *exec_ctx, + sockaddr_resolver *r); + +static void sockaddr_shutdown(grpc_exec_ctx *exec_ctx, grpc_resolver *r); +static void sockaddr_channel_saw_error(grpc_exec_ctx *exec_ctx, + grpc_resolver *r); +static void sockaddr_next(grpc_exec_ctx *exec_ctx, grpc_resolver *r, + grpc_client_config **target_config, + grpc_closure *on_complete); + +static const grpc_resolver_vtable sockaddr_resolver_vtable = { + sockaddr_destroy, sockaddr_shutdown, sockaddr_channel_saw_error, + sockaddr_next}; + +static void sockaddr_shutdown(grpc_exec_ctx *exec_ctx, + grpc_resolver *resolver) { + sockaddr_resolver *r = (sockaddr_resolver *)resolver; + gpr_mu_lock(&r->mu); + if (r->next_completion != NULL) { + *r->target_config = NULL; + grpc_exec_ctx_enqueue(exec_ctx, r->next_completion, true, NULL); + r->next_completion = NULL; + } + gpr_mu_unlock(&r->mu); +} + +static void sockaddr_channel_saw_error(grpc_exec_ctx *exec_ctx, + grpc_resolver *resolver) { + sockaddr_resolver *r = (sockaddr_resolver *)resolver; + gpr_mu_lock(&r->mu); + r->published = 0; + sockaddr_maybe_finish_next_locked(exec_ctx, r); + gpr_mu_unlock(&r->mu); +} + +static void sockaddr_next(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver, + grpc_client_config **target_config, + grpc_closure *on_complete) { + sockaddr_resolver *r = (sockaddr_resolver *)resolver; + gpr_mu_lock(&r->mu); + GPR_ASSERT(!r->next_completion); + r->next_completion = on_complete; + r->target_config = target_config; + sockaddr_maybe_finish_next_locked(exec_ctx, r); + gpr_mu_unlock(&r->mu); +} + +static void sockaddr_maybe_finish_next_locked(grpc_exec_ctx *exec_ctx, + sockaddr_resolver *r) { + grpc_client_config *cfg; + grpc_lb_policy *lb_policy; + grpc_lb_policy_args lb_policy_args; + grpc_subchannel **subchannels; + grpc_subchannel_args args; + + if (r->next_completion != NULL && !r->published) { + size_t i; + cfg = grpc_client_config_create(); + subchannels = gpr_malloc(sizeof(grpc_subchannel *) * r->num_addrs); + for (i = 0; i < r->num_addrs; i++) { + memset(&args, 0, sizeof(args)); + args.addr = (struct sockaddr *)&r->addrs[i]; + args.addr_len = r->addrs_len[i]; + subchannels[i] = grpc_subchannel_factory_create_subchannel( + exec_ctx, r->subchannel_factory, &args); + } + memset(&lb_policy_args, 0, sizeof(lb_policy_args)); + lb_policy_args.subchannels = subchannels; + lb_policy_args.num_subchannels = r->num_addrs; + lb_policy = grpc_lb_policy_create(r->lb_policy_name, &lb_policy_args); + gpr_free(subchannels); + grpc_client_config_set_lb_policy(cfg, lb_policy); + GRPC_LB_POLICY_UNREF(exec_ctx, lb_policy, "sockaddr"); + r->published = 1; + *r->target_config = cfg; + grpc_exec_ctx_enqueue(exec_ctx, r->next_completion, true, NULL); + r->next_completion = NULL; + } +} + +static void sockaddr_destroy(grpc_exec_ctx *exec_ctx, grpc_resolver *gr) { + sockaddr_resolver *r = (sockaddr_resolver *)gr; + gpr_mu_destroy(&r->mu); + grpc_subchannel_factory_unref(exec_ctx, r->subchannel_factory); + gpr_free(r->addrs); + gpr_free(r->addrs_len); + gpr_free(r->lb_policy_name); + gpr_free(r); +} + +static char *ip_get_default_authority(grpc_uri *uri) { + const char *path = uri->path; + if (path[0] == '/') ++path; + return gpr_strdup(path); +} + +static char *ipv4_get_default_authority(grpc_resolver_factory *factory, + grpc_uri *uri) { + return ip_get_default_authority(uri); +} + +static char *ipv6_get_default_authority(grpc_resolver_factory *factory, + grpc_uri *uri) { + return ip_get_default_authority(uri); +} + +static int parse_ipv4(grpc_uri *uri, struct sockaddr_storage *addr, + size_t *len) { + const char *host_port = uri->path; + char *host; + char *port; + int port_num; + int result = 0; + struct sockaddr_in *in = (struct sockaddr_in *)addr; + + if (*host_port == '/') ++host_port; + if (!gpr_split_host_port(host_port, &host, &port)) { + return 0; + } + + memset(in, 0, sizeof(*in)); + *len = sizeof(*in); + in->sin_family = AF_INET; + if (inet_pton(AF_INET, host, &in->sin_addr) == 0) { + gpr_log(GPR_ERROR, "invalid ipv4 address: '%s'", host); + goto done; + } + + if (port != NULL) { + if (sscanf(port, "%d", &port_num) != 1 || port_num < 0 || + port_num > 65535) { + gpr_log(GPR_ERROR, "invalid ipv4 port: '%s'", port); + goto done; + } + in->sin_port = htons((uint16_t)port_num); + } else { + gpr_log(GPR_ERROR, "no port given for ipv4 scheme"); + goto done; + } + + result = 1; +done: + gpr_free(host); + gpr_free(port); + return result; +} + +static int parse_ipv6(grpc_uri *uri, struct sockaddr_storage *addr, + size_t *len) { + const char *host_port = uri->path; + char *host; + char *port; + int port_num; + int result = 0; + struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)addr; + + if (*host_port == '/') ++host_port; + if (!gpr_split_host_port(host_port, &host, &port)) { + return 0; + } + + memset(in6, 0, sizeof(*in6)); + *len = sizeof(*in6); + in6->sin6_family = AF_INET6; + if (inet_pton(AF_INET6, host, &in6->sin6_addr) == 0) { + gpr_log(GPR_ERROR, "invalid ipv6 address: '%s'", host); + goto done; + } + + if (port != NULL) { + if (sscanf(port, "%d", &port_num) != 1 || port_num < 0 || + port_num > 65535) { + gpr_log(GPR_ERROR, "invalid ipv6 port: '%s'", port); + goto done; + } + in6->sin6_port = htons((uint16_t)port_num); + } else { + gpr_log(GPR_ERROR, "no port given for ipv6 scheme"); + goto done; + } + + result = 1; +done: + gpr_free(host); + gpr_free(port); + return result; +} + +static void do_nothing(void *ignored) {} + +static grpc_resolver *sockaddr_create( + grpc_resolver_args *args, const char *default_lb_policy_name, + int parse(grpc_uri *uri, struct sockaddr_storage *dst, size_t *len)) { + size_t i; + int errors_found = 0; /* GPR_FALSE */ + sockaddr_resolver *r; + gpr_slice path_slice; + gpr_slice_buffer path_parts; + + 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; + } + + r = gpr_malloc(sizeof(sockaddr_resolver)); + memset(r, 0, sizeof(*r)); + + r->lb_policy_name = NULL; + if (0 != strcmp(args->uri->query, "")) { + gpr_slice query_slice; + gpr_slice_buffer query_parts; + + query_slice = + gpr_slice_new(args->uri->query, strlen(args->uri->query), do_nothing); + gpr_slice_buffer_init(&query_parts); + gpr_slice_split(query_slice, "=", &query_parts); + GPR_ASSERT(query_parts.count == 2); + if (0 == gpr_slice_str_cmp(query_parts.slices[0], "lb_policy")) { + r->lb_policy_name = gpr_dump_slice(query_parts.slices[1], GPR_DUMP_ASCII); + } + gpr_slice_buffer_destroy(&query_parts); + gpr_slice_unref(query_slice); + } + if (r->lb_policy_name == NULL) { + r->lb_policy_name = gpr_strdup(default_lb_policy_name); + } + + path_slice = + gpr_slice_new(args->uri->path, strlen(args->uri->path), do_nothing); + gpr_slice_buffer_init(&path_parts); + + gpr_slice_split(path_slice, ",", &path_parts); + r->num_addrs = path_parts.count; + r->addrs = gpr_malloc(sizeof(struct sockaddr_storage) * r->num_addrs); + r->addrs_len = gpr_malloc(sizeof(*r->addrs_len) * r->num_addrs); + + for (i = 0; i < r->num_addrs; 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(&ith_uri, &r->addrs[i], &r->addrs_len[i])) { + errors_found = 1; /* GPR_TRUE */ + } + gpr_free(part_str); + 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->addrs); + gpr_free(r->addrs_len); + gpr_free(r); + return NULL; + } + + gpr_ref_init(&r->refs, 1); + gpr_mu_init(&r->mu); + grpc_resolver_init(&r->base, &sockaddr_resolver_vtable); + r->subchannel_factory = args->subchannel_factory; + grpc_subchannel_factory_ref(r->subchannel_factory); + + return &r->base; +} + +/* + * FACTORY + */ + +static void sockaddr_factory_ref(grpc_resolver_factory *factory) {} + +static void sockaddr_factory_unref(grpc_resolver_factory *factory) {} + +#define DECL_FACTORY(name, prefix) \ + static grpc_resolver *name##_factory_create_resolver( \ + grpc_resolver_factory *factory, grpc_resolver_args *args) { \ + return sockaddr_create(args, "pick_first", prefix##parse_##name); \ + } \ + static const grpc_resolver_factory_vtable name##_factory_vtable = { \ + sockaddr_factory_ref, sockaddr_factory_unref, \ + name##_factory_create_resolver, prefix##name##_get_default_authority, \ + #name}; \ + static grpc_resolver_factory name##_resolver_factory = { \ + &name##_factory_vtable}; \ + grpc_resolver_factory *grpc_##name##_resolver_factory_create() { \ + return &name##_resolver_factory; \ + } + +#ifdef GPR_HAVE_UNIX_SOCKET +DECL_FACTORY(unix, grpc_) +#endif +DECL_FACTORY(ipv4, ) DECL_FACTORY(ipv6, ) diff --git a/src/core/lib/client_config/resolvers/sockaddr_resolver.h b/src/core/lib/client_config/resolvers/sockaddr_resolver.h new file mode 100644 index 0000000000..f050329431 --- /dev/null +++ b/src/core/lib/client_config/resolvers/sockaddr_resolver.h @@ -0,0 +1,50 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_RESOLVERS_SOCKADDR_RESOLVER_H +#define GRPC_CORE_CLIENT_CONFIG_RESOLVERS_SOCKADDR_RESOLVER_H + +#include + +#include "src/core/client_config/resolver_factory.h" + +grpc_resolver_factory *grpc_ipv4_resolver_factory_create(void); + +grpc_resolver_factory *grpc_ipv6_resolver_factory_create(void); + +#ifdef GPR_POSIX_SOCKET +/** Create a unix resolver factory */ +grpc_resolver_factory *grpc_unix_resolver_factory_create(void); +#endif + +#endif /* GRPC_CORE_CLIENT_CONFIG_RESOLVERS_SOCKADDR_RESOLVER_H */ diff --git a/src/core/lib/client_config/resolvers/zookeeper_resolver.c b/src/core/lib/client_config/resolvers/zookeeper_resolver.c new file mode 100644 index 0000000000..e0e18792a2 --- /dev/null +++ b/src/core/lib/client_config/resolvers/zookeeper_resolver.c @@ -0,0 +1,520 @@ +/* + * + * Copyright 2015-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. + * + */ + +#include "src/core/client_config/resolvers/zookeeper_resolver.h" + +#include + +#include +#include + +#include +#include + +#include "src/core/client_config/lb_policy_registry.h" +#include "src/core/client_config/resolver_registry.h" +#include "src/core/iomgr/resolve_address.h" +#include "src/core/json/json.h" +#include "src/core/support/string.h" +#include "src/core/surface/api_trace.h" + +/** Zookeeper session expiration time in milliseconds */ +#define GRPC_ZOOKEEPER_SESSION_TIMEOUT 15000 + +typedef struct { + /** base class: must be first */ + grpc_resolver base; + /** refcount */ + gpr_refcount refs; + /** name to resolve */ + char *name; + /** subchannel factory */ + grpc_subchannel_factory *subchannel_factory; + /** load balancing policy name */ + char *lb_policy_name; + + /** mutex guarding the rest of the state */ + gpr_mu mu; + /** are we currently resolving? */ + int resolving; + /** which version of resolved_config have we published? */ + int published_version; + /** which version of resolved_config is current? */ + int resolved_version; + /** pending next completion, or NULL */ + grpc_closure *next_completion; + /** target config address for next completion */ + grpc_client_config **target_config; + /** current (fully resolved) config */ + grpc_client_config *resolved_config; + + /** zookeeper handle */ + zhandle_t *zookeeper_handle; + /** zookeeper resolved addresses */ + grpc_resolved_addresses *resolved_addrs; + /** total number of addresses to be resolved */ + int resolved_total; + /** number of addresses resolved */ + int resolved_num; +} zookeeper_resolver; + +static void zookeeper_destroy(grpc_exec_ctx *exec_ctx, grpc_resolver *r); + +static void zookeeper_start_resolving_locked(zookeeper_resolver *r); +static void zookeeper_maybe_finish_next_locked(grpc_exec_ctx *exec_ctx, + zookeeper_resolver *r); + +static void zookeeper_shutdown(grpc_exec_ctx *exec_ctx, grpc_resolver *r); +static void zookeeper_channel_saw_error(grpc_exec_ctx *exec_ctx, + grpc_resolver *r); +static void zookeeper_next(grpc_exec_ctx *exec_ctx, grpc_resolver *r, + grpc_client_config **target_config, + grpc_closure *on_complete); + +static const grpc_resolver_vtable zookeeper_resolver_vtable = { + zookeeper_destroy, zookeeper_shutdown, zookeeper_channel_saw_error, + zookeeper_next}; + +static void zookeeper_shutdown(grpc_exec_ctx *exec_ctx, + grpc_resolver *resolver) { + zookeeper_resolver *r = (zookeeper_resolver *)resolver; + grpc_closure *call = NULL; + gpr_mu_lock(&r->mu); + if (r->next_completion != NULL) { + *r->target_config = NULL; + call = r->next_completion; + r->next_completion = NULL; + } + zookeeper_close(r->zookeeper_handle); + gpr_mu_unlock(&r->mu); + if (call != NULL) { + call->cb(exec_ctx, call->cb_arg, 1); + } +} + +static void zookeeper_channel_saw_error(grpc_exec_ctx *exec_ctx, + grpc_resolver *resolver) { + zookeeper_resolver *r = (zookeeper_resolver *)resolver; + gpr_mu_lock(&r->mu); + if (r->resolving == 0) { + zookeeper_start_resolving_locked(r); + } + gpr_mu_unlock(&r->mu); +} + +static void zookeeper_next(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver, + grpc_client_config **target_config, + grpc_closure *on_complete) { + zookeeper_resolver *r = (zookeeper_resolver *)resolver; + gpr_mu_lock(&r->mu); + GPR_ASSERT(r->next_completion == NULL); + r->next_completion = on_complete; + r->target_config = target_config; + if (r->resolved_version == 0 && r->resolving == 0) { + zookeeper_start_resolving_locked(r); + } else { + zookeeper_maybe_finish_next_locked(exec_ctx, r); + } + gpr_mu_unlock(&r->mu); +} + +/** Zookeeper global watcher for connection management + TODO: better connection management besides logs */ +static void zookeeper_global_watcher(zhandle_t *zookeeper_handle, int type, + int state, const char *path, + void *watcher_ctx) { + if (type == ZOO_SESSION_EVENT) { + if (state == ZOO_EXPIRED_SESSION_STATE) { + gpr_log(GPR_ERROR, "Zookeeper session expired"); + } else if (state == ZOO_AUTH_FAILED_STATE) { + gpr_log(GPR_ERROR, "Zookeeper authentication failed"); + } + } +} + +/** Zookeeper watcher triggered by changes to watched nodes + Once triggered, it tries to resolve again to get updated addresses */ +static void zookeeper_watcher(zhandle_t *zookeeper_handle, int type, int state, + const char *path, void *watcher_ctx) { + if (watcher_ctx != NULL) { + zookeeper_resolver *r = (zookeeper_resolver *)watcher_ctx; + if (state == ZOO_CONNECTED_STATE) { + gpr_mu_lock(&r->mu); + if (r->resolving == 0) { + zookeeper_start_resolving_locked(r); + } + gpr_mu_unlock(&r->mu); + } + } +} + +/** Callback function after getting all resolved addresses + Creates a subchannel for each address */ +static void zookeeper_on_resolved(grpc_exec_ctx *exec_ctx, void *arg, + grpc_resolved_addresses *addresses) { + zookeeper_resolver *r = arg; + grpc_client_config *config = NULL; + grpc_subchannel **subchannels; + grpc_subchannel_args args; + grpc_lb_policy *lb_policy; + size_t i; + if (addresses != NULL) { + grpc_lb_policy_args lb_policy_args; + config = grpc_client_config_create(); + subchannels = gpr_malloc(sizeof(grpc_subchannel *) * addresses->naddrs); + for (i = 0; i < addresses->naddrs; i++) { + memset(&args, 0, sizeof(args)); + args.addr = (struct sockaddr *)(addresses->addrs[i].addr); + args.addr_len = addresses->addrs[i].len; + subchannels[i] = grpc_subchannel_factory_create_subchannel( + exec_ctx, r->subchannel_factory, &args); + } + lb_policy_args.subchannels = subchannels; + lb_policy_args.num_subchannels = addresses->naddrs; + lb_policy = grpc_lb_policy_create(r->lb_policy_name, &lb_policy_args); + grpc_client_config_set_lb_policy(config, lb_policy); + GRPC_LB_POLICY_UNREF(exec_ctx, lb_policy, "construction"); + grpc_resolved_addresses_destroy(addresses); + gpr_free(subchannels); + } + gpr_mu_lock(&r->mu); + GPR_ASSERT(r->resolving == 1); + r->resolving = 0; + if (r->resolved_config != NULL) { + grpc_client_config_unref(exec_ctx, r->resolved_config); + } + r->resolved_config = config; + r->resolved_version++; + zookeeper_maybe_finish_next_locked(exec_ctx, r); + gpr_mu_unlock(&r->mu); + + GRPC_RESOLVER_UNREF(exec_ctx, &r->base, "zookeeper-resolving"); +} + +/** Callback function for each DNS resolved address */ +static void zookeeper_dns_resolved(grpc_exec_ctx *exec_ctx, void *arg, + grpc_resolved_addresses *addresses) { + size_t i; + zookeeper_resolver *r = arg; + int resolve_done = 0; + + gpr_mu_lock(&r->mu); + r->resolved_num++; + r->resolved_addrs->addrs = + gpr_realloc(r->resolved_addrs->addrs, + sizeof(grpc_resolved_address) * + (r->resolved_addrs->naddrs + addresses->naddrs)); + for (i = 0; i < addresses->naddrs; i++) { + memcpy(r->resolved_addrs->addrs[i + r->resolved_addrs->naddrs].addr, + addresses->addrs[i].addr, addresses->addrs[i].len); + r->resolved_addrs->addrs[i + r->resolved_addrs->naddrs].len = + addresses->addrs[i].len; + } + + r->resolved_addrs->naddrs += addresses->naddrs; + grpc_resolved_addresses_destroy(addresses); + + /** Wait for all addresses to be resolved */ + resolve_done = (r->resolved_num == r->resolved_total); + gpr_mu_unlock(&r->mu); + if (resolve_done) { + zookeeper_on_resolved(exec_ctx, r, r->resolved_addrs); + } +} + +/** Parses JSON format address of a zookeeper node */ +static char *zookeeper_parse_address(const char *value, size_t value_len) { + grpc_json *json; + grpc_json *cur; + const char *host; + const char *port; + char *buffer; + char *address = NULL; + + buffer = gpr_malloc(value_len); + memcpy(buffer, value, value_len); + json = grpc_json_parse_string_with_len(buffer, value_len); + if (json != NULL) { + host = NULL; + port = NULL; + for (cur = json->child; cur != NULL; cur = cur->next) { + if (!strcmp(cur->key, "host")) { + host = cur->value; + if (port != NULL) { + break; + } + } else if (!strcmp(cur->key, "port")) { + port = cur->value; + if (host != NULL) { + break; + } + } + } + if (host != NULL && port != NULL) { + gpr_asprintf(&address, "%s:%s", host, port); + } + grpc_json_destroy(json); + } + gpr_free(buffer); + + return address; +} + +static void zookeeper_get_children_node_completion(int rc, const char *value, + int value_len, + const struct Stat *stat, + const void *arg) { + char *address = NULL; + zookeeper_resolver *r = (zookeeper_resolver *)arg; + int resolve_done = 0; + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + + if (rc != 0) { + gpr_log(GPR_ERROR, "Error in getting a child node of %s", r->name); + grpc_exec_ctx_finish(&exec_ctx); + return; + } + + address = zookeeper_parse_address(value, (size_t)value_len); + if (address != NULL) { + /** Further resolves address by DNS */ + grpc_resolve_address(address, NULL, zookeeper_dns_resolved, r); + gpr_free(address); + } else { + gpr_log(GPR_ERROR, "Error in resolving a child node of %s", r->name); + gpr_mu_lock(&r->mu); + r->resolved_total--; + resolve_done = (r->resolved_num == r->resolved_total); + gpr_mu_unlock(&r->mu); + if (resolve_done) { + zookeeper_on_resolved(&exec_ctx, r, r->resolved_addrs); + } + } + + grpc_exec_ctx_finish(&exec_ctx); +} + +static void zookeeper_get_children_completion( + int rc, const struct String_vector *children, const void *arg) { + char *path; + int status; + int i; + zookeeper_resolver *r = (zookeeper_resolver *)arg; + + if (rc != 0) { + gpr_log(GPR_ERROR, "Error in getting zookeeper children of %s", r->name); + return; + } + + if (children->count == 0) { + gpr_log(GPR_ERROR, "Error in resolving zookeeper address %s", r->name); + return; + } + + r->resolved_addrs = gpr_malloc(sizeof(grpc_resolved_addresses)); + r->resolved_addrs->addrs = NULL; + r->resolved_addrs->naddrs = 0; + r->resolved_total = children->count; + + /** TODO: Replace expensive heap allocation with stack + if we can get maximum length of zookeeper path */ + for (i = 0; i < children->count; i++) { + gpr_asprintf(&path, "%s/%s", r->name, children->data[i]); + status = zoo_awget(r->zookeeper_handle, path, zookeeper_watcher, r, + zookeeper_get_children_node_completion, r); + gpr_free(path); + if (status != 0) { + gpr_log(GPR_ERROR, "Error in getting zookeeper node %s", path); + } + } +} + +static void zookeeper_get_node_completion(int rc, const char *value, + int value_len, + const struct Stat *stat, + const void *arg) { + int status; + char *address = NULL; + zookeeper_resolver *r = (zookeeper_resolver *)arg; + r->resolved_addrs = NULL; + r->resolved_total = 0; + r->resolved_num = 0; + + if (rc != 0) { + gpr_log(GPR_ERROR, "Error in getting zookeeper node %s", r->name); + return; + } + + /** If zookeeper node of path r->name does not have address + (i.e. service node), get its children */ + address = zookeeper_parse_address(value, (size_t)value_len); + if (address != NULL) { + r->resolved_addrs = gpr_malloc(sizeof(grpc_resolved_addresses)); + r->resolved_addrs->addrs = NULL; + r->resolved_addrs->naddrs = 0; + r->resolved_total = 1; + /** Further resolves address by DNS */ + grpc_resolve_address(address, NULL, zookeeper_dns_resolved, r); + gpr_free(address); + return; + } + + status = zoo_awget_children(r->zookeeper_handle, r->name, zookeeper_watcher, + r, zookeeper_get_children_completion, r); + if (status != 0) { + gpr_log(GPR_ERROR, "Error in getting zookeeper children of %s", r->name); + } +} + +static void zookeeper_resolve_address(zookeeper_resolver *r) { + int status; + status = zoo_awget(r->zookeeper_handle, r->name, zookeeper_watcher, r, + zookeeper_get_node_completion, r); + if (status != 0) { + gpr_log(GPR_ERROR, "Error in getting zookeeper node %s", r->name); + } +} + +static void zookeeper_start_resolving_locked(zookeeper_resolver *r) { + GRPC_RESOLVER_REF(&r->base, "zookeeper-resolving"); + GPR_ASSERT(r->resolving == 0); + r->resolving = 1; + zookeeper_resolve_address(r); +} + +static void zookeeper_maybe_finish_next_locked(grpc_exec_ctx *exec_ctx, + zookeeper_resolver *r) { + if (r->next_completion != NULL && + r->resolved_version != r->published_version) { + *r->target_config = r->resolved_config; + if (r->resolved_config != NULL) { + grpc_client_config_ref(r->resolved_config); + } + grpc_exec_ctx_enqueue(exec_ctx, r->next_completion, true, NULL); + r->next_completion = NULL; + r->published_version = r->resolved_version; + } +} + +static void zookeeper_destroy(grpc_exec_ctx *exec_ctx, grpc_resolver *gr) { + zookeeper_resolver *r = (zookeeper_resolver *)gr; + gpr_mu_destroy(&r->mu); + if (r->resolved_config != NULL) { + grpc_client_config_unref(exec_ctx, r->resolved_config); + } + grpc_subchannel_factory_unref(exec_ctx, r->subchannel_factory); + gpr_free(r->name); + gpr_free(r->lb_policy_name); + gpr_free(r); +} + +static grpc_resolver *zookeeper_create(grpc_resolver_args *args, + const char *lb_policy_name) { + zookeeper_resolver *r; + size_t length; + char *path = args->uri->path; + + if (0 == strcmp(args->uri->authority, "")) { + gpr_log(GPR_ERROR, "No authority specified in zookeeper uri"); + return NULL; + } + + /** Removes the trailing slash if exists */ + length = strlen(path); + if (length > 1 && path[length - 1] == '/') { + path[length - 1] = 0; + } + + r = gpr_malloc(sizeof(zookeeper_resolver)); + memset(r, 0, sizeof(*r)); + gpr_ref_init(&r->refs, 1); + gpr_mu_init(&r->mu); + grpc_resolver_init(&r->base, &zookeeper_resolver_vtable); + r->name = gpr_strdup(path); + + r->subchannel_factory = args->subchannel_factory; + grpc_subchannel_factory_ref(r->subchannel_factory); + + r->lb_policy_name = gpr_strdup(lb_policy_name); + + /** Initializes zookeeper client */ + zoo_set_debug_level(ZOO_LOG_LEVEL_WARN); + r->zookeeper_handle = + zookeeper_init(args->uri->authority, zookeeper_global_watcher, + GRPC_ZOOKEEPER_SESSION_TIMEOUT, 0, 0, 0); + if (r->zookeeper_handle == NULL) { + gpr_log(GPR_ERROR, "Unable to connect to zookeeper server"); + return NULL; + } + + return &r->base; +} + +static void zookeeper_plugin_init() { + grpc_register_resolver_type(grpc_zookeeper_resolver_factory_create()); +} + +void grpc_zookeeper_register() { + GRPC_API_TRACE("grpc_zookeeper_register(void)", 0, ()); + grpc_register_plugin(zookeeper_plugin_init, NULL); +} + +/* + * FACTORY + */ + +static void zookeeper_factory_ref(grpc_resolver_factory *factory) {} + +static void zookeeper_factory_unref(grpc_resolver_factory *factory) {} + +static char *zookeeper_factory_get_default_hostname( + grpc_resolver_factory *factory, grpc_uri *uri) { + return NULL; +} + +static grpc_resolver *zookeeper_factory_create_resolver( + grpc_resolver_factory *factory, grpc_resolver_args *args) { + return zookeeper_create(args, "pick_first"); +} + +static const grpc_resolver_factory_vtable zookeeper_factory_vtable = { + zookeeper_factory_ref, zookeeper_factory_unref, + zookeeper_factory_create_resolver, zookeeper_factory_get_default_hostname, + "zookeeper"}; + +static grpc_resolver_factory zookeeper_resolver_factory = { + &zookeeper_factory_vtable}; + +grpc_resolver_factory *grpc_zookeeper_resolver_factory_create() { + return &zookeeper_resolver_factory; +} diff --git a/src/core/lib/client_config/resolvers/zookeeper_resolver.h b/src/core/lib/client_config/resolvers/zookeeper_resolver.h new file mode 100644 index 0000000000..04bd3ca875 --- /dev/null +++ b/src/core/lib/client_config/resolvers/zookeeper_resolver.h @@ -0,0 +1,42 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_RESOLVERS_ZOOKEEPER_RESOLVER_H +#define GRPC_CORE_CLIENT_CONFIG_RESOLVERS_ZOOKEEPER_RESOLVER_H + +#include "src/core/client_config/resolver_factory.h" + +/** Create a zookeeper resolver factory */ +grpc_resolver_factory *grpc_zookeeper_resolver_factory_create(void); + +#endif /* GRPC_CORE_CLIENT_CONFIG_RESOLVERS_ZOOKEEPER_RESOLVER_H */ diff --git a/src/core/lib/client_config/subchannel.c b/src/core/lib/client_config/subchannel.c new file mode 100644 index 0000000000..c5cd504929 --- /dev/null +++ b/src/core/lib/client_config/subchannel.c @@ -0,0 +1,678 @@ +/* + * + * Copyright 2015-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. + * + */ + +#include "src/core/client_config/subchannel.h" + +#include + +#include +#include + +#include "src/core/channel/channel_args.h" +#include "src/core/channel/client_channel.h" +#include "src/core/channel/connected_channel.h" +#include "src/core/client_config/initial_connect_string.h" +#include "src/core/client_config/subchannel_index.h" +#include "src/core/iomgr/timer.h" +#include "src/core/profiling/timers.h" +#include "src/core/support/backoff.h" +#include "src/core/surface/channel.h" +#include "src/core/surface/channel_init.h" +#include "src/core/transport/connectivity_state.h" + +#define INTERNAL_REF_BITS 16 +#define STRONG_REF_MASK (~(gpr_atm)((1 << INTERNAL_REF_BITS) - 1)) + +#define GRPC_SUBCHANNEL_MIN_CONNECT_TIMEOUT_SECONDS 20 +#define GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS 1 +#define GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER 1.6 +#define GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS 120 +#define GRPC_SUBCHANNEL_RECONNECT_JITTER 0.2 + +#define GET_CONNECTED_SUBCHANNEL(subchannel, barrier) \ + ((grpc_connected_subchannel *)(gpr_atm_##barrier##_load( \ + &(subchannel)->connected_subchannel))) + +typedef struct { + grpc_closure closure; + grpc_subchannel *subchannel; + grpc_connectivity_state connectivity_state; +} state_watcher; + +typedef struct external_state_watcher { + grpc_subchannel *subchannel; + grpc_pollset_set *pollset_set; + grpc_closure *notify; + grpc_closure closure; + struct external_state_watcher *next; + struct external_state_watcher *prev; +} external_state_watcher; + +struct grpc_subchannel { + grpc_connector *connector; + + /** refcount + - lower INTERNAL_REF_BITS bits are for internal references: + these do not keep the subchannel open. + - upper remaining bits are for public references: these do + keep the subchannel open */ + gpr_atm ref_pair; + + /** non-transport related channel filters */ + const grpc_channel_filter **filters; + size_t num_filters; + /** channel arguments */ + grpc_channel_args *args; + /** address to connect to */ + struct sockaddr *addr; + size_t addr_len; + + grpc_subchannel_key *key; + + /** initial string to send to peer */ + gpr_slice initial_connect_string; + + /** set during connection */ + grpc_connect_out_args connecting_result; + + /** callback for connection finishing */ + grpc_closure connected; + + /** pollset_set tracking who's interested in a connection + being setup */ + grpc_pollset_set *pollset_set; + + /** active connection, or null; of type grpc_connected_subchannel */ + gpr_atm connected_subchannel; + + /** mutex protecting remaining elements */ + gpr_mu mu; + + /** have we seen a disconnection? */ + int disconnected; + /** are we connecting */ + int connecting; + /** connectivity state tracking */ + grpc_connectivity_state_tracker state_tracker; + + external_state_watcher root_external_state_watcher; + + /** next connect attempt time */ + gpr_timespec next_attempt; + /** backoff state */ + gpr_backoff backoff_state; + /** do we have an active alarm? */ + int have_alarm; + /** our alarm */ + grpc_timer alarm; + /** current random value */ + uint32_t random; +}; + +struct grpc_subchannel_call { + grpc_connected_subchannel *connection; +}; + +#define SUBCHANNEL_CALL_TO_CALL_STACK(call) ((grpc_call_stack *)((call) + 1)) +#define CHANNEL_STACK_FROM_CONNECTION(con) ((grpc_channel_stack *)(con)) +#define CALLSTACK_TO_SUBCHANNEL_CALL(callstack) \ + (((grpc_subchannel_call *)(callstack)) - 1) + +static void subchannel_connected(grpc_exec_ctx *exec_ctx, void *subchannel, + bool iomgr_success); + +#ifdef GRPC_STREAM_REFCOUNT_DEBUG +#define REF_REASON reason +#define REF_LOG(name, p) \ + gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "%s: %p ref %d -> %d %s", \ + (name), (p), (p)->refs.count, (p)->refs.count + 1, reason) +#define UNREF_LOG(name, p) \ + gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "%s: %p unref %d -> %d %s", \ + (name), (p), (p)->refs.count, (p)->refs.count - 1, reason) +#define REF_MUTATE_EXTRA_ARGS \ + GRPC_SUBCHANNEL_REF_EXTRA_ARGS, const char *purpose +#define REF_MUTATE_PURPOSE(x) , file, line, reason, x +#else +#define REF_REASON "" +#define REF_LOG(name, p) \ + do { \ + } while (0) +#define UNREF_LOG(name, p) \ + do { \ + } while (0) +#define REF_MUTATE_EXTRA_ARGS +#define REF_MUTATE_PURPOSE(x) +#endif + +/* + * connection implementation + */ + +static void connection_destroy(grpc_exec_ctx *exec_ctx, void *arg, + bool success) { + grpc_connected_subchannel *c = arg; + grpc_channel_stack_destroy(exec_ctx, CHANNEL_STACK_FROM_CONNECTION(c)); + gpr_free(c); +} + +void grpc_connected_subchannel_ref( + grpc_connected_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) { + GRPC_CHANNEL_STACK_REF(CHANNEL_STACK_FROM_CONNECTION(c), REF_REASON); +} + +void grpc_connected_subchannel_unref(grpc_exec_ctx *exec_ctx, + grpc_connected_subchannel *c + GRPC_SUBCHANNEL_REF_EXTRA_ARGS) { + GRPC_CHANNEL_STACK_UNREF(exec_ctx, CHANNEL_STACK_FROM_CONNECTION(c), + REF_REASON); +} + +/* + * grpc_subchannel implementation + */ + +static void subchannel_destroy(grpc_exec_ctx *exec_ctx, void *arg, + bool success) { + grpc_subchannel *c = arg; + gpr_free((void *)c->filters); + grpc_channel_args_destroy(c->args); + gpr_free(c->addr); + gpr_slice_unref(c->initial_connect_string); + grpc_connectivity_state_destroy(exec_ctx, &c->state_tracker); + grpc_connector_unref(exec_ctx, c->connector); + grpc_pollset_set_destroy(c->pollset_set); + grpc_subchannel_key_destroy(exec_ctx, c->key); + gpr_free(c); +} + +static gpr_atm ref_mutate(grpc_subchannel *c, gpr_atm delta, + int barrier REF_MUTATE_EXTRA_ARGS) { + gpr_atm old_val = barrier ? gpr_atm_full_fetch_add(&c->ref_pair, delta) + : gpr_atm_no_barrier_fetch_add(&c->ref_pair, delta); +#ifdef GRPC_STREAM_REFCOUNT_DEBUG + gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, + "SUBCHANNEL: %p % 12s 0x%08x -> 0x%08x [%s]", c, purpose, old_val, + old_val + delta, reason); +#endif + return old_val; +} + +grpc_subchannel *grpc_subchannel_ref( + grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) { + gpr_atm old_refs; + old_refs = ref_mutate(c, (1 << INTERNAL_REF_BITS), + 0 REF_MUTATE_PURPOSE("STRONG_REF")); + GPR_ASSERT((old_refs & STRONG_REF_MASK) != 0); + return c; +} + +grpc_subchannel *grpc_subchannel_weak_ref( + grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) { + gpr_atm old_refs; + old_refs = ref_mutate(c, 1, 0 REF_MUTATE_PURPOSE("WEAK_REF")); + GPR_ASSERT(old_refs != 0); + return c; +} + +grpc_subchannel *grpc_subchannel_ref_from_weak_ref( + grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) { + if (!c) return NULL; + for (;;) { + gpr_atm old_refs = gpr_atm_acq_load(&c->ref_pair); + if (old_refs >= (1 << INTERNAL_REF_BITS)) { + gpr_atm new_refs = old_refs + (1 << INTERNAL_REF_BITS); + if (gpr_atm_rel_cas(&c->ref_pair, old_refs, new_refs)) { + return c; + } + } else { + return NULL; + } + } +} + +static void disconnect(grpc_exec_ctx *exec_ctx, grpc_subchannel *c) { + grpc_connected_subchannel *con; + grpc_subchannel_index_unregister(exec_ctx, c->key, c); + gpr_mu_lock(&c->mu); + GPR_ASSERT(!c->disconnected); + c->disconnected = 1; + grpc_connector_shutdown(exec_ctx, c->connector); + con = GET_CONNECTED_SUBCHANNEL(c, no_barrier); + if (con != NULL) { + GRPC_CONNECTED_SUBCHANNEL_UNREF(exec_ctx, con, "connection"); + gpr_atm_no_barrier_store(&c->connected_subchannel, 0xdeadbeef); + } + gpr_mu_unlock(&c->mu); +} + +void grpc_subchannel_unref(grpc_exec_ctx *exec_ctx, + grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) { + gpr_atm old_refs; + old_refs = ref_mutate(c, (gpr_atm)1 - (gpr_atm)(1 << INTERNAL_REF_BITS), + 1 REF_MUTATE_PURPOSE("STRONG_UNREF")); + if ((old_refs & STRONG_REF_MASK) == (1 << INTERNAL_REF_BITS)) { + disconnect(exec_ctx, c); + } + GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "strong-unref"); +} + +void grpc_subchannel_weak_unref(grpc_exec_ctx *exec_ctx, + grpc_subchannel *c + GRPC_SUBCHANNEL_REF_EXTRA_ARGS) { + gpr_atm old_refs; + old_refs = ref_mutate(c, -(gpr_atm)1, 1 REF_MUTATE_PURPOSE("WEAK_UNREF")); + if (old_refs == 1) { + grpc_exec_ctx_enqueue(exec_ctx, grpc_closure_create(subchannel_destroy, c), + true, NULL); + } +} + +static uint32_t random_seed() { + return (uint32_t)(gpr_time_to_millis(gpr_now(GPR_CLOCK_MONOTONIC))); +} + +grpc_subchannel *grpc_subchannel_create(grpc_exec_ctx *exec_ctx, + grpc_connector *connector, + grpc_subchannel_args *args) { + grpc_subchannel_key *key = grpc_subchannel_key_create(connector, args); + grpc_subchannel *c = grpc_subchannel_index_find(exec_ctx, key); + if (c) { + grpc_subchannel_key_destroy(exec_ctx, key); + return c; + } + + c = gpr_malloc(sizeof(*c)); + memset(c, 0, sizeof(*c)); + c->key = key; + gpr_atm_no_barrier_store(&c->ref_pair, 1 << INTERNAL_REF_BITS); + c->connector = connector; + grpc_connector_ref(c->connector); + c->num_filters = args->filter_count; + if (c->num_filters > 0) { + c->filters = gpr_malloc(sizeof(grpc_channel_filter *) * c->num_filters); + memcpy((void *)c->filters, args->filters, + sizeof(grpc_channel_filter *) * c->num_filters); + } else { + c->filters = NULL; + } + c->addr = gpr_malloc(args->addr_len); + memcpy(c->addr, args->addr, args->addr_len); + c->pollset_set = grpc_pollset_set_create(); + c->addr_len = args->addr_len; + grpc_set_initial_connect_string(&c->addr, &c->addr_len, + &c->initial_connect_string); + c->args = grpc_channel_args_copy(args->args); + c->random = random_seed(); + c->root_external_state_watcher.next = c->root_external_state_watcher.prev = + &c->root_external_state_watcher; + grpc_closure_init(&c->connected, subchannel_connected, c); + grpc_connectivity_state_init(&c->state_tracker, GRPC_CHANNEL_IDLE, + "subchannel"); + gpr_backoff_init(&c->backoff_state, + GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER, + GRPC_SUBCHANNEL_RECONNECT_JITTER, + GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS * 1000, + GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS * 1000); + if (c->args) { + for (size_t i = 0; i < c->args->num_args; i++) { + if (0 == strcmp(c->args->args[i].key, + "grpc.testing.fixed_reconnect_backoff")) { + GPR_ASSERT(c->args->args[i].type == GRPC_ARG_INTEGER); + gpr_backoff_init(&c->backoff_state, 1.0, 0.0, + c->args->args[i].value.integer, + c->args->args[i].value.integer); + } + } + } + gpr_mu_init(&c->mu); + + return grpc_subchannel_index_register(exec_ctx, key, c); +} + +static void continue_connect(grpc_exec_ctx *exec_ctx, grpc_subchannel *c) { + grpc_connect_in_args args; + + args.interested_parties = c->pollset_set; + args.addr = c->addr; + args.addr_len = c->addr_len; + args.deadline = c->next_attempt; + args.channel_args = c->args; + args.initial_connect_string = c->initial_connect_string; + + grpc_connectivity_state_set(exec_ctx, &c->state_tracker, + GRPC_CHANNEL_CONNECTING, "state_change"); + grpc_connector_connect(exec_ctx, c->connector, &args, &c->connecting_result, + &c->connected); +} + +static void start_connect(grpc_exec_ctx *exec_ctx, grpc_subchannel *c) { + c->next_attempt = + gpr_backoff_begin(&c->backoff_state, gpr_now(GPR_CLOCK_MONOTONIC)); + continue_connect(exec_ctx, c); +} + +grpc_connectivity_state grpc_subchannel_check_connectivity(grpc_subchannel *c) { + grpc_connectivity_state state; + gpr_mu_lock(&c->mu); + state = grpc_connectivity_state_check(&c->state_tracker); + gpr_mu_unlock(&c->mu); + return state; +} + +static void on_external_state_watcher_done(grpc_exec_ctx *exec_ctx, void *arg, + bool success) { + external_state_watcher *w = arg; + grpc_closure *follow_up = w->notify; + if (w->pollset_set != NULL) { + grpc_pollset_set_del_pollset_set(exec_ctx, w->subchannel->pollset_set, + w->pollset_set); + } + gpr_mu_lock(&w->subchannel->mu); + w->next->prev = w->prev; + w->prev->next = w->next; + gpr_mu_unlock(&w->subchannel->mu); + GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, w->subchannel, "external_state_watcher"); + gpr_free(w); + follow_up->cb(exec_ctx, follow_up->cb_arg, success); +} + +void grpc_subchannel_notify_on_state_change( + grpc_exec_ctx *exec_ctx, grpc_subchannel *c, + grpc_pollset_set *interested_parties, grpc_connectivity_state *state, + grpc_closure *notify) { + external_state_watcher *w; + + if (state == NULL) { + gpr_mu_lock(&c->mu); + for (w = c->root_external_state_watcher.next; + w != &c->root_external_state_watcher; w = w->next) { + if (w->notify == notify) { + grpc_connectivity_state_notify_on_state_change( + exec_ctx, &c->state_tracker, NULL, &w->closure); + } + } + gpr_mu_unlock(&c->mu); + } else { + w = gpr_malloc(sizeof(*w)); + w->subchannel = c; + w->pollset_set = interested_parties; + w->notify = notify; + grpc_closure_init(&w->closure, on_external_state_watcher_done, w); + if (interested_parties != NULL) { + grpc_pollset_set_add_pollset_set(exec_ctx, c->pollset_set, + interested_parties); + } + GRPC_SUBCHANNEL_WEAK_REF(c, "external_state_watcher"); + gpr_mu_lock(&c->mu); + w->next = &c->root_external_state_watcher; + w->prev = w->next->prev; + w->next->prev = w->prev->next = w; + if (grpc_connectivity_state_notify_on_state_change( + exec_ctx, &c->state_tracker, state, &w->closure)) { + c->connecting = 1; + /* released by connection */ + GRPC_SUBCHANNEL_WEAK_REF(c, "connecting"); + start_connect(exec_ctx, c); + } + gpr_mu_unlock(&c->mu); + } +} + +void grpc_connected_subchannel_process_transport_op( + grpc_exec_ctx *exec_ctx, grpc_connected_subchannel *con, + grpc_transport_op *op) { + grpc_channel_stack *channel_stack = CHANNEL_STACK_FROM_CONNECTION(con); + grpc_channel_element *top_elem = grpc_channel_stack_element(channel_stack, 0); + top_elem->filter->start_transport_op(exec_ctx, top_elem, op); +} + +static void subchannel_on_child_state_changed(grpc_exec_ctx *exec_ctx, void *p, + bool iomgr_success) { + state_watcher *sw = p; + grpc_subchannel *c = sw->subchannel; + gpr_mu *mu = &c->mu; + + gpr_mu_lock(mu); + + /* if we failed just leave this closure */ + if (iomgr_success) { + if (sw->connectivity_state == GRPC_CHANNEL_TRANSIENT_FAILURE) { + /* any errors on a subchannel ==> we're done, create a new one */ + sw->connectivity_state = GRPC_CHANNEL_FATAL_FAILURE; + } + grpc_connectivity_state_set(exec_ctx, &c->state_tracker, + sw->connectivity_state, "reflect_child"); + if (sw->connectivity_state != GRPC_CHANNEL_FATAL_FAILURE) { + grpc_connected_subchannel_notify_on_state_change( + exec_ctx, GET_CONNECTED_SUBCHANNEL(c, no_barrier), NULL, + &sw->connectivity_state, &sw->closure); + GRPC_SUBCHANNEL_WEAK_REF(c, "state_watcher"); + sw = NULL; + } + } + + gpr_mu_unlock(mu); + GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "state_watcher"); + gpr_free(sw); +} + +static void connected_subchannel_state_op(grpc_exec_ctx *exec_ctx, + grpc_connected_subchannel *con, + grpc_pollset_set *interested_parties, + grpc_connectivity_state *state, + grpc_closure *closure) { + grpc_transport_op op; + grpc_channel_element *elem; + memset(&op, 0, sizeof(op)); + op.connectivity_state = state; + op.on_connectivity_state_change = closure; + op.bind_pollset_set = interested_parties; + elem = grpc_channel_stack_element(CHANNEL_STACK_FROM_CONNECTION(con), 0); + elem->filter->start_transport_op(exec_ctx, elem, &op); +} + +void grpc_connected_subchannel_notify_on_state_change( + grpc_exec_ctx *exec_ctx, grpc_connected_subchannel *con, + grpc_pollset_set *interested_parties, grpc_connectivity_state *state, + grpc_closure *closure) { + connected_subchannel_state_op(exec_ctx, con, interested_parties, state, + closure); +} + +void grpc_connected_subchannel_ping(grpc_exec_ctx *exec_ctx, + grpc_connected_subchannel *con, + grpc_closure *closure) { + grpc_transport_op op; + grpc_channel_element *elem; + memset(&op, 0, sizeof(op)); + op.send_ping = closure; + elem = grpc_channel_stack_element(CHANNEL_STACK_FROM_CONNECTION(con), 0); + elem->filter->start_transport_op(exec_ctx, elem, &op); +} + +static void publish_transport_locked(grpc_exec_ctx *exec_ctx, + grpc_subchannel *c) { + grpc_connected_subchannel *con; + grpc_channel_stack *stk; + state_watcher *sw_subchannel; + + /* construct channel stack */ + con = grpc_channel_init_create_stack( + exec_ctx, GRPC_CLIENT_SUBCHANNEL, 0, c->connecting_result.channel_args, 1, + connection_destroy, NULL, c->connecting_result.transport); + stk = CHANNEL_STACK_FROM_CONNECTION(con); + memset(&c->connecting_result, 0, sizeof(c->connecting_result)); + + /* initialize state watcher */ + sw_subchannel = gpr_malloc(sizeof(*sw_subchannel)); + sw_subchannel->subchannel = c; + sw_subchannel->connectivity_state = GRPC_CHANNEL_READY; + grpc_closure_init(&sw_subchannel->closure, subchannel_on_child_state_changed, + sw_subchannel); + + if (c->disconnected) { + gpr_free(sw_subchannel); + grpc_channel_stack_destroy(exec_ctx, stk); + gpr_free(con); + GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "connecting"); + return; + } + + /* publish */ + /* TODO(ctiller): this full barrier seems to clear up a TSAN failure. + I'd have expected the rel_cas below to be enough, but + seemingly it's not. + Re-evaluate if we really need this. */ + gpr_atm_full_barrier(); + GPR_ASSERT(gpr_atm_rel_cas(&c->connected_subchannel, 0, (gpr_atm)con)); + c->connecting = 0; + + /* setup subchannel watching connected subchannel for changes; subchannel ref + for connecting is donated + to the state watcher */ + GRPC_SUBCHANNEL_WEAK_REF(c, "state_watcher"); + GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "connecting"); + grpc_connected_subchannel_notify_on_state_change( + exec_ctx, con, c->pollset_set, &sw_subchannel->connectivity_state, + &sw_subchannel->closure); + + /* signal completion */ + grpc_connectivity_state_set(exec_ctx, &c->state_tracker, GRPC_CHANNEL_READY, + "connected"); +} + +static void on_alarm(grpc_exec_ctx *exec_ctx, void *arg, bool iomgr_success) { + grpc_subchannel *c = arg; + gpr_mu_lock(&c->mu); + c->have_alarm = 0; + if (c->disconnected) { + iomgr_success = 0; + } + if (iomgr_success) { + c->next_attempt = + gpr_backoff_step(&c->backoff_state, gpr_now(GPR_CLOCK_MONOTONIC)); + continue_connect(exec_ctx, c); + gpr_mu_unlock(&c->mu); + } else { + gpr_mu_unlock(&c->mu); + GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "connecting"); + } +} + +static void subchannel_connected(grpc_exec_ctx *exec_ctx, void *arg, + bool iomgr_success) { + grpc_subchannel *c = arg; + + GRPC_SUBCHANNEL_WEAK_REF(c, "connected"); + gpr_mu_lock(&c->mu); + if (c->connecting_result.transport != NULL) { + publish_transport_locked(exec_ctx, c); + } else if (c->disconnected) { + GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "connecting"); + } else { + gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC); + GPR_ASSERT(!c->have_alarm); + c->have_alarm = 1; + grpc_connectivity_state_set(exec_ctx, &c->state_tracker, + GRPC_CHANNEL_TRANSIENT_FAILURE, + "connect_failed"); + grpc_timer_init(exec_ctx, &c->alarm, c->next_attempt, on_alarm, c, now); + } + gpr_mu_unlock(&c->mu); + GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "connecting"); +} + +/* + * grpc_subchannel_call implementation + */ + +static void subchannel_call_destroy(grpc_exec_ctx *exec_ctx, void *call, + bool success) { + grpc_subchannel_call *c = call; + GPR_TIMER_BEGIN("grpc_subchannel_call_unref.destroy", 0); + grpc_call_stack_destroy(exec_ctx, SUBCHANNEL_CALL_TO_CALL_STACK(c)); + GRPC_CONNECTED_SUBCHANNEL_UNREF(exec_ctx, c->connection, "subchannel_call"); + gpr_free(c); + GPR_TIMER_END("grpc_subchannel_call_unref.destroy", 0); +} + +void grpc_subchannel_call_ref( + grpc_subchannel_call *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) { + GRPC_CALL_STACK_REF(SUBCHANNEL_CALL_TO_CALL_STACK(c), REF_REASON); +} + +void grpc_subchannel_call_unref(grpc_exec_ctx *exec_ctx, + grpc_subchannel_call *c + GRPC_SUBCHANNEL_REF_EXTRA_ARGS) { + GRPC_CALL_STACK_UNREF(exec_ctx, SUBCHANNEL_CALL_TO_CALL_STACK(c), REF_REASON); +} + +char *grpc_subchannel_call_get_peer(grpc_exec_ctx *exec_ctx, + grpc_subchannel_call *call) { + grpc_call_stack *call_stack = SUBCHANNEL_CALL_TO_CALL_STACK(call); + grpc_call_element *top_elem = grpc_call_stack_element(call_stack, 0); + return top_elem->filter->get_peer(exec_ctx, top_elem); +} + +void grpc_subchannel_call_process_op(grpc_exec_ctx *exec_ctx, + grpc_subchannel_call *call, + grpc_transport_stream_op *op) { + grpc_call_stack *call_stack = SUBCHANNEL_CALL_TO_CALL_STACK(call); + grpc_call_element *top_elem = grpc_call_stack_element(call_stack, 0); + top_elem->filter->start_transport_stream_op(exec_ctx, top_elem, op); +} + +grpc_connected_subchannel *grpc_subchannel_get_connected_subchannel( + grpc_subchannel *c) { + return GET_CONNECTED_SUBCHANNEL(c, acq); +} + +grpc_subchannel_call *grpc_connected_subchannel_create_call( + grpc_exec_ctx *exec_ctx, grpc_connected_subchannel *con, + grpc_pollset *pollset) { + grpc_channel_stack *chanstk = CHANNEL_STACK_FROM_CONNECTION(con); + grpc_subchannel_call *call = + gpr_malloc(sizeof(grpc_subchannel_call) + chanstk->call_stack_size); + grpc_call_stack *callstk = SUBCHANNEL_CALL_TO_CALL_STACK(call); + call->connection = con; + GRPC_CONNECTED_SUBCHANNEL_REF(con, "subchannel_call"); + grpc_call_stack_init(exec_ctx, chanstk, 1, subchannel_call_destroy, call, + NULL, NULL, callstk); + grpc_call_stack_set_pollset(exec_ctx, callstk, pollset); + return call; +} + +grpc_call_stack *grpc_subchannel_call_get_call_stack( + grpc_subchannel_call *subchannel_call) { + return SUBCHANNEL_CALL_TO_CALL_STACK(subchannel_call); +} diff --git a/src/core/lib/client_config/subchannel.h b/src/core/lib/client_config/subchannel.h new file mode 100644 index 0000000000..83e1c58a4c --- /dev/null +++ b/src/core/lib/client_config/subchannel.h @@ -0,0 +1,174 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_SUBCHANNEL_H +#define GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_H + +#include "src/core/channel/channel_stack.h" +#include "src/core/client_config/connector.h" +#include "src/core/transport/connectivity_state.h" + +/** A (sub-)channel that knows how to connect to exactly one target + address. Provides a target for load balancing. */ +typedef struct grpc_subchannel grpc_subchannel; +typedef struct grpc_connected_subchannel grpc_connected_subchannel; +typedef struct grpc_subchannel_call grpc_subchannel_call; +typedef struct grpc_subchannel_args grpc_subchannel_args; + +#ifdef GRPC_STREAM_REFCOUNT_DEBUG +#define GRPC_SUBCHANNEL_REF(p, r) \ + grpc_subchannel_ref((p), __FILE__, __LINE__, (r)) +#define GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(p, r) \ + grpc_subchannel_ref_from_weak_ref((p), __FILE__, __LINE__, (r)) +#define GRPC_SUBCHANNEL_UNREF(cl, p, r) \ + grpc_subchannel_unref((cl), (p), __FILE__, __LINE__, (r)) +#define GRPC_SUBCHANNEL_WEAK_REF(p, r) \ + grpc_subchannel_weak_ref((p), __FILE__, __LINE__, (r)) +#define GRPC_SUBCHANNEL_WEAK_UNREF(cl, p, r) \ + grpc_subchannel_weak_unref((cl), (p), __FILE__, __LINE__, (r)) +#define GRPC_CONNECTED_SUBCHANNEL_REF(p, r) \ + grpc_connected_subchannel_ref((p), __FILE__, __LINE__, (r)) +#define GRPC_CONNECTED_SUBCHANNEL_UNREF(cl, p, r) \ + grpc_connected_subchannel_unref((cl), (p), __FILE__, __LINE__, (r)) +#define GRPC_SUBCHANNEL_CALL_REF(p, r) \ + grpc_subchannel_call_ref((p), __FILE__, __LINE__, (r)) +#define GRPC_SUBCHANNEL_CALL_UNREF(cl, p, r) \ + grpc_subchannel_call_unref((cl), (p), __FILE__, __LINE__, (r)) +#define GRPC_SUBCHANNEL_REF_EXTRA_ARGS \ + , const char *file, int line, const char *reason +#else +#define GRPC_SUBCHANNEL_REF(p, r) grpc_subchannel_ref((p)) +#define GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(p, r) \ + grpc_subchannel_ref_from_weak_ref((p)) +#define GRPC_SUBCHANNEL_UNREF(cl, p, r) grpc_subchannel_unref((cl), (p)) +#define GRPC_SUBCHANNEL_WEAK_REF(p, r) grpc_subchannel_weak_ref((p)) +#define GRPC_SUBCHANNEL_WEAK_UNREF(cl, p, r) \ + grpc_subchannel_weak_unref((cl), (p)) +#define GRPC_CONNECTED_SUBCHANNEL_REF(p, r) grpc_connected_subchannel_ref((p)) +#define GRPC_CONNECTED_SUBCHANNEL_UNREF(cl, p, r) \ + grpc_connected_subchannel_unref((cl), (p)) +#define GRPC_SUBCHANNEL_CALL_REF(p, r) grpc_subchannel_call_ref((p)) +#define GRPC_SUBCHANNEL_CALL_UNREF(cl, p, r) \ + grpc_subchannel_call_unref((cl), (p)) +#define GRPC_SUBCHANNEL_REF_EXTRA_ARGS +#endif + +grpc_subchannel *grpc_subchannel_ref( + grpc_subchannel *channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS); +grpc_subchannel *grpc_subchannel_ref_from_weak_ref( + grpc_subchannel *channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS); +void grpc_subchannel_unref(grpc_exec_ctx *exec_ctx, + grpc_subchannel *channel + GRPC_SUBCHANNEL_REF_EXTRA_ARGS); +grpc_subchannel *grpc_subchannel_weak_ref( + grpc_subchannel *channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS); +void grpc_subchannel_weak_unref(grpc_exec_ctx *exec_ctx, + grpc_subchannel *channel + GRPC_SUBCHANNEL_REF_EXTRA_ARGS); +void grpc_connected_subchannel_ref( + grpc_connected_subchannel *channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS); +void grpc_connected_subchannel_unref(grpc_exec_ctx *exec_ctx, + grpc_connected_subchannel *channel + GRPC_SUBCHANNEL_REF_EXTRA_ARGS); +void grpc_subchannel_call_ref( + grpc_subchannel_call *call GRPC_SUBCHANNEL_REF_EXTRA_ARGS); +void grpc_subchannel_call_unref(grpc_exec_ctx *exec_ctx, + grpc_subchannel_call *call + GRPC_SUBCHANNEL_REF_EXTRA_ARGS); + +/** construct a subchannel call */ +grpc_subchannel_call *grpc_connected_subchannel_create_call( + grpc_exec_ctx *exec_ctx, grpc_connected_subchannel *connected_subchannel, + grpc_pollset *pollset); + +/** process a transport level op */ +void grpc_connected_subchannel_process_transport_op( + grpc_exec_ctx *exec_ctx, grpc_connected_subchannel *subchannel, + grpc_transport_op *op); + +/** poll the current connectivity state of a channel */ +grpc_connectivity_state grpc_subchannel_check_connectivity( + grpc_subchannel *channel); + +/** call notify when the connectivity state of a channel changes from *state. + Updates *state with the new state of the channel */ +void grpc_subchannel_notify_on_state_change( + grpc_exec_ctx *exec_ctx, grpc_subchannel *channel, + grpc_pollset_set *interested_parties, grpc_connectivity_state *state, + grpc_closure *notify); +void grpc_connected_subchannel_notify_on_state_change( + grpc_exec_ctx *exec_ctx, grpc_connected_subchannel *channel, + grpc_pollset_set *interested_parties, grpc_connectivity_state *state, + grpc_closure *notify); +void grpc_connected_subchannel_ping(grpc_exec_ctx *exec_ctx, + grpc_connected_subchannel *channel, + grpc_closure *notify); + +/** retrieve the grpc_connected_subchannel - or NULL if called before + the subchannel becomes connected */ +grpc_connected_subchannel *grpc_subchannel_get_connected_subchannel( + grpc_subchannel *subchannel); + +/** continue processing a transport op */ +void grpc_subchannel_call_process_op(grpc_exec_ctx *exec_ctx, + grpc_subchannel_call *subchannel_call, + grpc_transport_stream_op *op); + +/** continue querying for peer */ +char *grpc_subchannel_call_get_peer(grpc_exec_ctx *exec_ctx, + grpc_subchannel_call *subchannel_call); + +grpc_call_stack *grpc_subchannel_call_get_call_stack( + grpc_subchannel_call *subchannel_call); + +struct grpc_subchannel_args { + /* When updating this struct, also update subchannel_index.c */ + + /** Channel filters for this channel - wrapped factories will likely + want to mutate this */ + const grpc_channel_filter **filters; + /** The number of filters in the above array */ + size_t filter_count; + /** Channel arguments to be supplied to the newly created channel */ + const grpc_channel_args *args; + /** Address to connect to */ + struct sockaddr *addr; + size_t addr_len; +}; + +/** create a subchannel given a connector */ +grpc_subchannel *grpc_subchannel_create(grpc_exec_ctx *exec_ctx, + grpc_connector *connector, + grpc_subchannel_args *args); + +#endif /* GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_H */ diff --git a/src/core/lib/client_config/subchannel_factory.c b/src/core/lib/client_config/subchannel_factory.c new file mode 100644 index 0000000000..2c64219e8b --- /dev/null +++ b/src/core/lib/client_config/subchannel_factory.c @@ -0,0 +1,49 @@ +/* + * + * Copyright 2015, 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/client_config/subchannel_factory.h" + +void grpc_subchannel_factory_ref(grpc_subchannel_factory* factory) { + factory->vtable->ref(factory); +} + +void grpc_subchannel_factory_unref(grpc_exec_ctx* exec_ctx, + grpc_subchannel_factory* factory) { + factory->vtable->unref(exec_ctx, factory); +} + +grpc_subchannel* grpc_subchannel_factory_create_subchannel( + grpc_exec_ctx* exec_ctx, grpc_subchannel_factory* factory, + grpc_subchannel_args* args) { + return factory->vtable->create_subchannel(exec_ctx, factory, args); +} diff --git a/src/core/lib/client_config/subchannel_factory.h b/src/core/lib/client_config/subchannel_factory.h new file mode 100644 index 0000000000..c638f377a6 --- /dev/null +++ b/src/core/lib/client_config/subchannel_factory.h @@ -0,0 +1,66 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_SUBCHANNEL_FACTORY_H +#define GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_FACTORY_H + +#include "src/core/channel/channel_stack.h" +#include "src/core/client_config/subchannel.h" + +typedef struct grpc_subchannel_factory grpc_subchannel_factory; +typedef struct grpc_subchannel_factory_vtable grpc_subchannel_factory_vtable; + +/** Constructor for new configured channels. + Creating decorators around this type is encouraged to adapt behavior. */ +struct grpc_subchannel_factory { + const grpc_subchannel_factory_vtable *vtable; +}; + +struct grpc_subchannel_factory_vtable { + void (*ref)(grpc_subchannel_factory *factory); + void (*unref)(grpc_exec_ctx *exec_ctx, grpc_subchannel_factory *factory); + grpc_subchannel *(*create_subchannel)(grpc_exec_ctx *exec_ctx, + grpc_subchannel_factory *factory, + grpc_subchannel_args *args); +}; + +void grpc_subchannel_factory_ref(grpc_subchannel_factory *factory); +void grpc_subchannel_factory_unref(grpc_exec_ctx *exec_ctx, + grpc_subchannel_factory *factory); + +/** Create a new grpc_subchannel */ +grpc_subchannel *grpc_subchannel_factory_create_subchannel( + grpc_exec_ctx *exec_ctx, grpc_subchannel_factory *factory, + grpc_subchannel_args *args); + +#endif /* GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_FACTORY_H */ diff --git a/src/core/lib/client_config/subchannel_index.c b/src/core/lib/client_config/subchannel_index.c new file mode 100644 index 0000000000..24cc76cf22 --- /dev/null +++ b/src/core/lib/client_config/subchannel_index.c @@ -0,0 +1,262 @@ +// +// +// 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. +// +// + +#include "src/core/client_config/subchannel_index.h" + +#include +#include + +#include +#include +#include + +#include "src/core/channel/channel_args.h" + +// a map of subchannel_key --> subchannel, used for detecting connections +// to the same destination in order to share them +static gpr_avl g_subchannel_index; + +static gpr_mu g_mu; + +struct grpc_subchannel_key { + grpc_connector *connector; + grpc_subchannel_args args; +}; + +GPR_TLS_DECL(subchannel_index_exec_ctx); + +static void enter_ctx(grpc_exec_ctx *exec_ctx) { + GPR_ASSERT(gpr_tls_get(&subchannel_index_exec_ctx) == 0); + gpr_tls_set(&subchannel_index_exec_ctx, (intptr_t)exec_ctx); +} + +static void leave_ctx(grpc_exec_ctx *exec_ctx) { + GPR_ASSERT(gpr_tls_get(&subchannel_index_exec_ctx) == (intptr_t)exec_ctx); + gpr_tls_set(&subchannel_index_exec_ctx, 0); +} + +static grpc_exec_ctx *current_ctx() { + grpc_exec_ctx *c = (grpc_exec_ctx *)gpr_tls_get(&subchannel_index_exec_ctx); + GPR_ASSERT(c != NULL); + return c; +} + +static grpc_subchannel_key *create_key( + grpc_connector *connector, grpc_subchannel_args *args, + grpc_channel_args *(*copy_channel_args)(const grpc_channel_args *args)) { + grpc_subchannel_key *k = gpr_malloc(sizeof(*k)); + k->connector = grpc_connector_ref(connector); + k->args.filter_count = args->filter_count; + k->args.filters = gpr_malloc(sizeof(*k->args.filters) * k->args.filter_count); + memcpy((grpc_channel_filter *)k->args.filters, args->filters, + sizeof(*k->args.filters) * k->args.filter_count); + k->args.addr_len = args->addr_len; + k->args.addr = gpr_malloc(args->addr_len); + memcpy(k->args.addr, args->addr, k->args.addr_len); + k->args.args = copy_channel_args(args->args); + return k; +} + +grpc_subchannel_key *grpc_subchannel_key_create(grpc_connector *connector, + grpc_subchannel_args *args) { + return create_key(connector, args, grpc_channel_args_normalize); +} + +static grpc_subchannel_key *subchannel_key_copy(grpc_subchannel_key *k) { + return create_key(k->connector, &k->args, grpc_channel_args_copy); +} + +static int subchannel_key_compare(grpc_subchannel_key *a, + grpc_subchannel_key *b) { + int c = GPR_ICMP(a->connector, b->connector); + if (c != 0) return c; + c = GPR_ICMP(a->args.addr_len, b->args.addr_len); + if (c != 0) return c; + c = GPR_ICMP(a->args.filter_count, b->args.filter_count); + if (c != 0) return c; + c = memcmp(a->args.addr, b->args.addr, a->args.addr_len); + if (c != 0) return c; + c = memcmp(a->args.filters, b->args.filters, + a->args.filter_count * sizeof(*a->args.filters)); + if (c != 0) return c; + return grpc_channel_args_compare(a->args.args, b->args.args); +} + +void grpc_subchannel_key_destroy(grpc_exec_ctx *exec_ctx, + grpc_subchannel_key *k) { + grpc_connector_unref(exec_ctx, k->connector); + gpr_free(k->args.addr); + gpr_free((grpc_channel_args *)k->args.filters); + grpc_channel_args_destroy((grpc_channel_args *)k->args.args); + gpr_free(k); +} + +static void sck_avl_destroy(void *p) { + grpc_subchannel_key_destroy(current_ctx(), p); +} + +static void *sck_avl_copy(void *p) { return subchannel_key_copy(p); } + +static long sck_avl_compare(void *a, void *b) { + return subchannel_key_compare(a, b); +} + +static void scv_avl_destroy(void *p) { + GRPC_SUBCHANNEL_WEAK_UNREF(current_ctx(), p, "subchannel_index"); +} + +static void *scv_avl_copy(void *p) { + GRPC_SUBCHANNEL_WEAK_REF(p, "subchannel_index"); + return p; +} + +static const gpr_avl_vtable subchannel_avl_vtable = { + .destroy_key = sck_avl_destroy, + .copy_key = sck_avl_copy, + .compare_keys = sck_avl_compare, + .destroy_value = scv_avl_destroy, + .copy_value = scv_avl_copy}; + +void grpc_subchannel_index_init(void) { + g_subchannel_index = gpr_avl_create(&subchannel_avl_vtable); + gpr_mu_init(&g_mu); + gpr_tls_init(&subchannel_index_exec_ctx); +} + +void grpc_subchannel_index_shutdown(void) { + gpr_mu_destroy(&g_mu); + gpr_avl_unref(g_subchannel_index); + gpr_tls_destroy(&subchannel_index_exec_ctx); +} + +grpc_subchannel *grpc_subchannel_index_find(grpc_exec_ctx *exec_ctx, + grpc_subchannel_key *key) { + enter_ctx(exec_ctx); + + // Lock, and take a reference to the subchannel index. + // We don't need to do the search under a lock as avl's are immutable. + gpr_mu_lock(&g_mu); + gpr_avl index = gpr_avl_ref(g_subchannel_index); + gpr_mu_unlock(&g_mu); + + grpc_subchannel *c = + GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(gpr_avl_get(index, key), "index_find"); + gpr_avl_unref(index); + + leave_ctx(exec_ctx); + return c; +} + +grpc_subchannel *grpc_subchannel_index_register(grpc_exec_ctx *exec_ctx, + grpc_subchannel_key *key, + grpc_subchannel *constructed) { + enter_ctx(exec_ctx); + + grpc_subchannel *c = NULL; + + while (c == NULL) { + // Compare and swap loop: + // - take a reference to the current index + gpr_mu_lock(&g_mu); + gpr_avl index = gpr_avl_ref(g_subchannel_index); + gpr_mu_unlock(&g_mu); + + // - Check to see if a subchannel already exists + c = gpr_avl_get(index, key); + if (c != NULL) { + // yes -> we're done + GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, constructed, "index_register"); + } else { + // no -> update the avl and compare/swap + gpr_avl updated = + gpr_avl_add(gpr_avl_ref(index), subchannel_key_copy(key), + GRPC_SUBCHANNEL_WEAK_REF(constructed, "index_register")); + + // it may happen (but it's expected to be unlikely) + // that some other thread has changed the index: + // compare/swap here to check that, and retry as necessary + gpr_mu_lock(&g_mu); + if (index.root == g_subchannel_index.root) { + GPR_SWAP(gpr_avl, updated, g_subchannel_index); + c = constructed; + } + gpr_mu_unlock(&g_mu); + + gpr_avl_unref(updated); + } + gpr_avl_unref(index); + } + + leave_ctx(exec_ctx); + + return c; +} + +void grpc_subchannel_index_unregister(grpc_exec_ctx *exec_ctx, + grpc_subchannel_key *key, + grpc_subchannel *constructed) { + enter_ctx(exec_ctx); + + bool done = false; + while (!done) { + // Compare and swap loop: + // - take a reference to the current index + gpr_mu_lock(&g_mu); + gpr_avl index = gpr_avl_ref(g_subchannel_index); + gpr_mu_unlock(&g_mu); + + // Check to see if this key still refers to the previously + // registered subchannel + grpc_subchannel *c = gpr_avl_get(index, key); + if (c != constructed) { + gpr_avl_unref(index); + break; + } + + // compare and swap the update (some other thread may have + // mutated the index behind us) + gpr_avl updated = gpr_avl_remove(gpr_avl_ref(index), key); + + gpr_mu_lock(&g_mu); + if (index.root == g_subchannel_index.root) { + GPR_SWAP(gpr_avl, updated, g_subchannel_index); + done = true; + } + gpr_mu_unlock(&g_mu); + + gpr_avl_unref(updated); + gpr_avl_unref(index); + } + + leave_ctx(exec_ctx); +} diff --git a/src/core/lib/client_config/subchannel_index.h b/src/core/lib/client_config/subchannel_index.h new file mode 100644 index 0000000000..3cd5d12349 --- /dev/null +++ b/src/core/lib/client_config/subchannel_index.h @@ -0,0 +1,77 @@ +/* + * + * 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_CORE_CLIENT_CONFIG_SUBCHANNEL_INDEX_H +#define GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_INDEX_H + +#include "src/core/client_config/connector.h" +#include "src/core/client_config/subchannel.h" + +/** \file Provides an index of active subchannels so that they can be + shared amongst channels */ + +typedef struct grpc_subchannel_key grpc_subchannel_key; + +/** Create a key that can be used to uniquely identify a subchannel */ +grpc_subchannel_key *grpc_subchannel_key_create(grpc_connector *con, + grpc_subchannel_args *args); + +/** Destroy a subchannel key */ +void grpc_subchannel_key_destroy(grpc_exec_ctx *exec_ctx, + grpc_subchannel_key *key); + +/** Given a subchannel key, find the subchannel registered for it. + Returns NULL if no such channel exists. + Thread-safe. */ +grpc_subchannel *grpc_subchannel_index_find(grpc_exec_ctx *exec_ctx, + grpc_subchannel_key *key); + +/** Register a subchannel against a key. + Takes ownership of \a constructed. + Returns the registered subchannel. This may be different from + \a constructed in the case of a registration race. */ +grpc_subchannel *grpc_subchannel_index_register(grpc_exec_ctx *exec_ctx, + grpc_subchannel_key *key, + grpc_subchannel *constructed); + +/** Remove \a constructed as the registered subchannel for \a key. */ +void grpc_subchannel_index_unregister(grpc_exec_ctx *exec_ctx, + grpc_subchannel_key *key, + grpc_subchannel *constructed); + +/** Initialize the subchannel index (global) */ +void grpc_subchannel_index_init(void); +/** Shutdown the subchannel index (global) */ +void grpc_subchannel_index_shutdown(void); + +#endif /* GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_INDEX_H */ diff --git a/src/core/lib/client_config/uri_parser.c b/src/core/lib/client_config/uri_parser.c new file mode 100644 index 0000000000..cbdfffcf8e --- /dev/null +++ b/src/core/lib/client_config/uri_parser.c @@ -0,0 +1,242 @@ +/* + * + * Copyright 2015, 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/client_config/uri_parser.h" + +#include + +#include +#include +#include +#include + +/** a size_t default value... maps to all 1's */ +#define NOT_SET (~(size_t)0) + +static grpc_uri *bad_uri(const char *uri_text, size_t pos, const char *section, + int suppress_errors) { + char *line_prefix; + size_t pfx_len; + + if (!suppress_errors) { + gpr_asprintf(&line_prefix, "bad uri.%s: '", section); + pfx_len = strlen(line_prefix) + pos; + gpr_log(GPR_ERROR, "%s%s'", line_prefix, uri_text); + gpr_free(line_prefix); + + line_prefix = gpr_malloc(pfx_len + 1); + memset(line_prefix, ' ', pfx_len); + line_prefix[pfx_len] = 0; + gpr_log(GPR_ERROR, "%s^ here", line_prefix); + gpr_free(line_prefix); + } + + return NULL; +} + +/** Returns a copy of \a src[begin, end) */ +static char *copy_component(const char *src, size_t begin, size_t end) { + char *out = gpr_malloc(end - begin + 1); + memcpy(out, src + begin, end - begin); + out[end - begin] = 0; + return out; +} + +/** Returns how many chars to advance if \a uri_text[i] begins a valid \a pchar + * production. If \a uri_text[i] introduces an invalid \a pchar (such as percent + * sign not followed by two hex digits), NOT_SET is returned. */ +static size_t parse_pchar(const char *uri_text, size_t i) { + /* pchar = unreserved / pct-encoded / sub-delims / ":" / "@" + * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" + * pct-encoded = "%" HEXDIG HEXDIG + * sub-delims = "!" / "$" / "&" / "'" / "(" / ")" + / "*" / "+" / "," / ";" / "=" */ + char c = uri_text[i]; + if (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')) || + ((c >= '0') && (c <= '9')) || + (c == '-' || c == '.' || c == '_' || c == '~') || /* unreserved */ + (c == '!' || c == '$' || c == '&' || c == '\'' || c == '$' || c == '&' || + c == '(' || c == ')' || c == '*' || c == '+' || c == ',' || c == ';' || + c == '=') /* sub-delims */) { + return 1; + } + if (c == '%') { /* pct-encoded */ + size_t j; + if (uri_text[i + 1] == 0 || uri_text[i + 2] == 0) { + return NOT_SET; + } + for (j = i + 1; j < 2; j++) { + c = uri_text[j]; + if (!(((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f')) || + ((c >= 'A') && (c <= 'F')))) { + return NOT_SET; + } + } + return 2; + } + return 0; +} + +/* *( pchar / "?" / "/" ) */ +static int parse_fragment_or_query(const char *uri_text, size_t *i) { + char c; + while ((c = uri_text[*i]) != 0) { + const size_t advance = parse_pchar(uri_text, *i); /* pchar */ + switch (advance) { + case 0: /* uri_text[i] isn't in pchar */ + /* maybe it's ? or / */ + if (uri_text[*i] == '?' || uri_text[*i] == '/') { + (*i)++; + break; + } else { + return 1; + } + GPR_UNREACHABLE_CODE(return 0); + default: + (*i) += advance; + break; + case NOT_SET: /* uri_text[i] introduces an invalid URI */ + return 0; + } + } + /* *i is the first uri_text position past the \a query production, maybe \0 */ + return 1; +} + +grpc_uri *grpc_uri_parse(const char *uri_text, int suppress_errors) { + grpc_uri *uri; + size_t scheme_begin = 0; + size_t scheme_end = NOT_SET; + size_t authority_begin = NOT_SET; + size_t authority_end = NOT_SET; + size_t path_begin = NOT_SET; + size_t path_end = NOT_SET; + size_t query_begin = NOT_SET; + size_t query_end = NOT_SET; + size_t fragment_begin = NOT_SET; + size_t fragment_end = NOT_SET; + size_t i; + + for (i = scheme_begin; uri_text[i] != 0; i++) { + if (uri_text[i] == ':') { + scheme_end = i; + break; + } + if (uri_text[i] >= 'a' && uri_text[i] <= 'z') continue; + if (uri_text[i] >= 'A' && uri_text[i] <= 'Z') continue; + if (i != scheme_begin) { + if (uri_text[i] >= '0' && uri_text[i] <= '9') continue; + if (uri_text[i] == '+') continue; + if (uri_text[i] == '-') continue; + if (uri_text[i] == '.') continue; + } + break; + } + if (scheme_end == NOT_SET) { + return bad_uri(uri_text, i, "scheme", suppress_errors); + } + + if (uri_text[scheme_end + 1] == '/' && uri_text[scheme_end + 2] == '/') { + authority_begin = scheme_end + 3; + for (i = authority_begin; uri_text[i] != 0 && authority_end == NOT_SET; + i++) { + if (uri_text[i] == '/' || uri_text[i] == '?' || uri_text[i] == '#') { + authority_end = i; + } + } + if (authority_end == NOT_SET && uri_text[i] == 0) { + authority_end = i; + } + if (authority_end == NOT_SET) { + return bad_uri(uri_text, i, "authority", suppress_errors); + } + /* TODO(ctiller): parse the authority correctly */ + path_begin = authority_end; + } else { + path_begin = scheme_end + 1; + } + + for (i = path_begin; uri_text[i] != 0; i++) { + if (uri_text[i] == '?' || uri_text[i] == '#') { + path_end = i; + break; + } + } + if (path_end == NOT_SET && uri_text[i] == 0) { + path_end = i; + } + if (path_end == NOT_SET) { + return bad_uri(uri_text, i, "path", suppress_errors); + } + + if (uri_text[i] == '?') { + query_begin = ++i; + if (!parse_fragment_or_query(uri_text, &i)) { + return bad_uri(uri_text, i, "query", suppress_errors); + } else if (uri_text[i] != 0 && uri_text[i] != '#') { + /* We must be at the end or at the beginning of a fragment */ + return bad_uri(uri_text, i, "query", suppress_errors); + } + query_end = i; + } + if (uri_text[i] == '#') { + fragment_begin = ++i; + if (!parse_fragment_or_query(uri_text, &i)) { + return bad_uri(uri_text, i - fragment_end, "fragment", suppress_errors); + } else if (uri_text[i] != 0) { + /* We must be at the end */ + return bad_uri(uri_text, i, "fragment", suppress_errors); + } + fragment_end = i; + } + + uri = gpr_malloc(sizeof(*uri)); + memset(uri, 0, sizeof(*uri)); + uri->scheme = copy_component(uri_text, scheme_begin, scheme_end); + uri->authority = copy_component(uri_text, authority_begin, authority_end); + uri->path = copy_component(uri_text, path_begin, path_end); + uri->query = copy_component(uri_text, query_begin, query_end); + uri->fragment = copy_component(uri_text, fragment_begin, fragment_end); + + return uri; +} + +void grpc_uri_destroy(grpc_uri *uri) { + if (!uri) return; + gpr_free(uri->scheme); + gpr_free(uri->authority); + gpr_free(uri->path); + gpr_free(uri->query); + gpr_free(uri->fragment); + gpr_free(uri); +} diff --git a/src/core/lib/client_config/uri_parser.h b/src/core/lib/client_config/uri_parser.h new file mode 100644 index 0000000000..af013d8cac --- /dev/null +++ b/src/core/lib/client_config/uri_parser.h @@ -0,0 +1,51 @@ +/* + * + * Copyright 2015-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_CORE_CLIENT_CONFIG_URI_PARSER_H +#define GRPC_CORE_CLIENT_CONFIG_URI_PARSER_H + +typedef struct { + char *scheme; + char *authority; + char *path; + char *query; + char *fragment; +} grpc_uri; + +/** parse a uri, return NULL on failure */ +grpc_uri *grpc_uri_parse(const char *uri_text, int suppress_errors); + +/** destroy a uri */ +void grpc_uri_destroy(grpc_uri *uri); + +#endif /* GRPC_CORE_CLIENT_CONFIG_URI_PARSER_H */ -- cgit v1.2.3 From 9a4dddd8b5d4ae968e5ddd52edbef7af92b7a440 Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Fri, 25 Mar 2016 17:08:13 -0700 Subject: Fix include guards --- src/core/lib/census/aggregation.h | 6 +++--- src/core/lib/census/grpc_filter.h | 6 +++--- src/core/lib/census/grpc_plugin.h | 6 +++--- src/core/lib/census/mlog.h | 6 +++--- src/core/lib/census/rpc_metric_id.h | 6 +++--- src/core/lib/channel/channel_args.h | 6 +++--- src/core/lib/channel/channel_stack.h | 6 +++--- src/core/lib/channel/channel_stack_builder.h | 6 +++--- src/core/lib/channel/client_channel.h | 6 +++--- src/core/lib/channel/compress_filter.h | 6 +++--- src/core/lib/channel/connected_channel.h | 6 +++--- src/core/lib/channel/context.h | 6 +++--- src/core/lib/channel/http_client_filter.h | 6 +++--- src/core/lib/channel/http_server_filter.h | 6 +++--- src/core/lib/channel/subchannel_call_holder.h | 6 +++--- src/core/lib/client_config/client_config.h | 6 +++--- src/core/lib/client_config/connector.h | 6 +++--- src/core/lib/client_config/initial_connect_string.h | 6 +++--- src/core/lib/client_config/lb_policies/load_balancer_api.h | 6 +++--- src/core/lib/client_config/lb_policies/pick_first.h | 6 +++--- src/core/lib/client_config/lb_policies/round_robin.h | 6 +++--- src/core/lib/client_config/lb_policy.h | 6 +++--- src/core/lib/client_config/lb_policy_factory.h | 6 +++--- src/core/lib/client_config/lb_policy_registry.h | 6 +++--- src/core/lib/client_config/resolver.h | 6 +++--- src/core/lib/client_config/resolver_factory.h | 6 +++--- src/core/lib/client_config/resolver_registry.h | 6 +++--- src/core/lib/client_config/resolvers/dns_resolver.h | 6 +++--- src/core/lib/client_config/resolvers/sockaddr_resolver.h | 6 +++--- src/core/lib/client_config/resolvers/zookeeper_resolver.h | 6 +++--- src/core/lib/client_config/subchannel.h | 6 +++--- src/core/lib/client_config/subchannel_factory.h | 6 +++--- src/core/lib/client_config/subchannel_index.h | 6 +++--- src/core/lib/client_config/uri_parser.h | 6 +++--- src/core/lib/compression/algorithm_metadata.h | 6 +++--- src/core/lib/compression/message_compress.h | 6 +++--- src/core/lib/debug/trace.h | 6 +++--- src/core/lib/http/format_request.h | 6 +++--- src/core/lib/http/httpcli.h | 6 +++--- src/core/lib/http/parser.h | 6 +++--- src/core/lib/iomgr/closure.h | 6 +++--- src/core/lib/iomgr/endpoint.h | 6 +++--- src/core/lib/iomgr/endpoint_pair.h | 6 +++--- src/core/lib/iomgr/exec_ctx.h | 6 +++--- src/core/lib/iomgr/executor.h | 6 +++--- src/core/lib/iomgr/fd_posix.h | 6 +++--- src/core/lib/iomgr/iocp_windows.h | 6 +++--- src/core/lib/iomgr/iomgr.h | 6 +++--- src/core/lib/iomgr/iomgr_internal.h | 6 +++--- src/core/lib/iomgr/iomgr_posix.h | 6 +++--- src/core/lib/iomgr/pollset.h | 6 +++--- src/core/lib/iomgr/pollset_posix.h | 6 +++--- src/core/lib/iomgr/pollset_set.h | 6 +++--- src/core/lib/iomgr/pollset_set_posix.h | 6 +++--- src/core/lib/iomgr/pollset_set_windows.h | 6 +++--- src/core/lib/iomgr/pollset_windows.h | 6 +++--- src/core/lib/iomgr/resolve_address.h | 6 +++--- src/core/lib/iomgr/sockaddr.h | 6 +++--- src/core/lib/iomgr/sockaddr_posix.h | 6 +++--- src/core/lib/iomgr/sockaddr_utils.h | 6 +++--- src/core/lib/iomgr/sockaddr_win32.h | 6 +++--- src/core/lib/iomgr/socket_utils_posix.h | 6 +++--- src/core/lib/iomgr/socket_windows.h | 6 +++--- src/core/lib/iomgr/tcp_client.h | 6 +++--- src/core/lib/iomgr/tcp_posix.h | 6 +++--- src/core/lib/iomgr/tcp_server.h | 6 +++--- src/core/lib/iomgr/tcp_windows.h | 6 +++--- src/core/lib/iomgr/time_averaged_stats.h | 6 +++--- src/core/lib/iomgr/timer.h | 6 +++--- src/core/lib/iomgr/timer_heap.h | 6 +++--- src/core/lib/iomgr/udp_server.h | 6 +++--- src/core/lib/iomgr/unix_sockets_posix.h | 6 +++--- src/core/lib/iomgr/wakeup_fd_pipe.h | 6 +++--- src/core/lib/iomgr/wakeup_fd_posix.h | 6 +++--- src/core/lib/iomgr/workqueue.h | 6 +++--- src/core/lib/iomgr/workqueue_posix.h | 6 +++--- src/core/lib/iomgr/workqueue_windows.h | 6 +++--- src/core/lib/json/json.h | 6 +++--- src/core/lib/json/json_common.h | 6 +++--- src/core/lib/json/json_reader.h | 6 +++--- src/core/lib/json/json_writer.h | 6 +++--- src/core/lib/profiling/timers.h | 6 +++--- src/core/lib/proto/grpc/lb/v0/load_balancer.pb.h | 6 +++--- src/core/lib/security/auth_filters.h | 6 +++--- src/core/lib/security/b64.h | 6 +++--- src/core/lib/security/credentials.h | 6 +++--- src/core/lib/security/handshake.h | 6 +++--- src/core/lib/security/json_token.h | 6 +++--- src/core/lib/security/jwt_verifier.h | 6 +++--- src/core/lib/security/secure_endpoint.h | 6 +++--- src/core/lib/security/security_connector.h | 6 +++--- src/core/lib/security/security_context.h | 6 +++--- src/core/lib/statistics/census_interface.h | 6 +++--- src/core/lib/statistics/census_log.h | 6 +++--- src/core/lib/statistics/census_rpc_stats.h | 6 +++--- src/core/lib/statistics/census_tracing.h | 6 +++--- src/core/lib/statistics/hash_table.h | 6 +++--- src/core/lib/statistics/window_stats.h | 6 +++--- src/core/lib/support/backoff.h | 6 +++--- src/core/lib/support/block_annotate.h | 6 +++--- src/core/lib/support/env.h | 6 +++--- src/core/lib/support/load_file.h | 6 +++--- src/core/lib/support/murmur_hash.h | 6 +++--- src/core/lib/support/stack_lockfree.h | 6 +++--- src/core/lib/support/string.h | 6 +++--- src/core/lib/support/string_win32.h | 6 +++--- src/core/lib/support/thd_internal.h | 6 +++--- src/core/lib/support/time_precise.h | 6 +++--- src/core/lib/support/tmpfile.h | 6 +++--- src/core/lib/surface/api_trace.h | 6 +++--- src/core/lib/surface/call.h | 6 +++--- src/core/lib/surface/call_test_only.h | 6 +++--- src/core/lib/surface/channel.h | 6 +++--- src/core/lib/surface/channel_init.h | 6 +++--- src/core/lib/surface/channel_stack_type.h | 6 +++--- src/core/lib/surface/completion_queue.h | 6 +++--- src/core/lib/surface/event_string.h | 6 +++--- src/core/lib/surface/init.h | 6 +++--- src/core/lib/surface/lame_client.h | 6 +++--- src/core/lib/surface/server.h | 6 +++--- src/core/lib/surface/surface_trace.h | 6 +++--- src/core/lib/transport/byte_stream.h | 6 +++--- src/core/lib/transport/chttp2/alpn.h | 6 +++--- src/core/lib/transport/chttp2/bin_encoder.h | 6 +++--- src/core/lib/transport/chttp2/frame.h | 6 +++--- src/core/lib/transport/chttp2/frame_data.h | 6 +++--- src/core/lib/transport/chttp2/frame_goaway.h | 6 +++--- src/core/lib/transport/chttp2/frame_ping.h | 6 +++--- src/core/lib/transport/chttp2/frame_rst_stream.h | 6 +++--- src/core/lib/transport/chttp2/frame_settings.h | 6 +++--- src/core/lib/transport/chttp2/frame_window_update.h | 6 +++--- src/core/lib/transport/chttp2/hpack_encoder.h | 6 +++--- src/core/lib/transport/chttp2/hpack_parser.h | 6 +++--- src/core/lib/transport/chttp2/hpack_table.h | 6 +++--- src/core/lib/transport/chttp2/http2_errors.h | 6 +++--- src/core/lib/transport/chttp2/huffsyms.h | 6 +++--- src/core/lib/transport/chttp2/incoming_metadata.h | 6 +++--- src/core/lib/transport/chttp2/internal.h | 6 +++--- src/core/lib/transport/chttp2/status_conversion.h | 6 +++--- src/core/lib/transport/chttp2/stream_map.h | 6 +++--- src/core/lib/transport/chttp2/timeout_encoding.h | 6 +++--- src/core/lib/transport/chttp2/varint.h | 6 +++--- src/core/lib/transport/chttp2_transport.h | 6 +++--- src/core/lib/transport/connectivity_state.h | 6 +++--- src/core/lib/transport/metadata.h | 6 +++--- src/core/lib/transport/metadata_batch.h | 6 +++--- src/core/lib/transport/static_metadata.h | 6 +++--- src/core/lib/transport/transport.h | 6 +++--- src/core/lib/transport/transport_impl.h | 6 +++--- src/core/lib/tsi/fake_transport_security.h | 6 +++--- src/core/lib/tsi/ssl_transport_security.h | 6 +++--- src/core/lib/tsi/ssl_types.h | 6 +++--- src/core/lib/tsi/transport_security.h | 6 +++--- src/core/lib/tsi/transport_security_interface.h | 6 +++--- 154 files changed, 462 insertions(+), 462 deletions(-) (limited to 'src/core/lib/client_config') diff --git a/src/core/lib/census/aggregation.h b/src/core/lib/census/aggregation.h index e0ef9630c9..f353368b97 100644 --- a/src/core/lib/census/aggregation.h +++ b/src/core/lib/census/aggregation.h @@ -33,8 +33,8 @@ #include -#ifndef GRPC_CORE_CENSUS_AGGREGATION_H -#define GRPC_CORE_CENSUS_AGGREGATION_H +#ifndef GRPC_CORE_LIB_CENSUS_AGGREGATION_H +#define GRPC_CORE_LIB_CENSUS_AGGREGATION_H /** Structure used to describe an aggregation type. */ struct census_aggregation_ops { @@ -63,4 +63,4 @@ struct census_aggregation_ops { size_t (*print)(const void *aggregation, char *buffer, size_t n); }; -#endif /* GRPC_CORE_CENSUS_AGGREGATION_H */ +#endif /* GRPC_CORE_LIB_CENSUS_AGGREGATION_H */ diff --git a/src/core/lib/census/grpc_filter.h b/src/core/lib/census/grpc_filter.h index 4699e4d692..e71346b357 100644 --- a/src/core/lib/census/grpc_filter.h +++ b/src/core/lib/census/grpc_filter.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CENSUS_GRPC_FILTER_H -#define GRPC_CORE_CENSUS_GRPC_FILTER_H +#ifndef GRPC_CORE_LIB_CENSUS_GRPC_FILTER_H +#define GRPC_CORE_LIB_CENSUS_GRPC_FILTER_H #include "src/core/channel/channel_stack.h" @@ -41,4 +41,4 @@ extern const grpc_channel_filter grpc_client_census_filter; extern const grpc_channel_filter grpc_server_census_filter; -#endif /* GRPC_CORE_CENSUS_GRPC_FILTER_H */ +#endif /* GRPC_CORE_LIB_CENSUS_GRPC_FILTER_H */ diff --git a/src/core/lib/census/grpc_plugin.h b/src/core/lib/census/grpc_plugin.h index 9321c2c30f..33e5f0b701 100644 --- a/src/core/lib/census/grpc_plugin.h +++ b/src/core/lib/census/grpc_plugin.h @@ -31,10 +31,10 @@ * */ -#ifndef GRPC_CORE_CENSUS_GRPC_PLUGIN_H -#define GRPC_CORE_CENSUS_GRPC_PLUGIN_H +#ifndef GRPC_CORE_LIB_CENSUS_GRPC_PLUGIN_H +#define GRPC_CORE_LIB_CENSUS_GRPC_PLUGIN_H void census_grpc_plugin_init(void); void census_grpc_plugin_destroy(void); -#endif /* GRPC_CORE_CENSUS_GRPC_PLUGIN_H */ +#endif /* GRPC_CORE_LIB_CENSUS_GRPC_PLUGIN_H */ diff --git a/src/core/lib/census/mlog.h b/src/core/lib/census/mlog.h index bc6eaeaf28..7fbdeda986 100644 --- a/src/core/lib/census/mlog.h +++ b/src/core/lib/census/mlog.h @@ -33,8 +33,8 @@ /* A very fast in-memory log, optimized for multiple writers. */ -#ifndef GRPC_CORE_CENSUS_MLOG_H -#define GRPC_CORE_CENSUS_MLOG_H +#ifndef GRPC_CORE_LIB_CENSUS_MLOG_H +#define GRPC_CORE_LIB_CENSUS_MLOG_H #include #include @@ -92,4 +92,4 @@ size_t census_log_remaining_space(void); out-of-space. */ int64_t census_log_out_of_space_count(void); -#endif /* GRPC_CORE_CENSUS_MLOG_H */ +#endif /* GRPC_CORE_LIB_CENSUS_MLOG_H */ diff --git a/src/core/lib/census/rpc_metric_id.h b/src/core/lib/census/rpc_metric_id.h index f8d8dad0bf..aad0588fb3 100644 --- a/src/core/lib/census/rpc_metric_id.h +++ b/src/core/lib/census/rpc_metric_id.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CENSUS_RPC_METRIC_ID_H -#define GRPC_CORE_CENSUS_RPC_METRIC_ID_H +#ifndef GRPC_CORE_LIB_CENSUS_RPC_METRIC_ID_H +#define GRPC_CORE_LIB_CENSUS_RPC_METRIC_ID_H /* Metric ID's used for RPC measurements. */ /* Count of client requests sent. */ @@ -48,4 +48,4 @@ /* Server side request latency. */ #define CENSUS_METRIC_RPC_SERVER_LATENCY ((uint32_t)5) -#endif /* GRPC_CORE_CENSUS_RPC_METRIC_ID_H */ +#endif /* GRPC_CORE_LIB_CENSUS_RPC_METRIC_ID_H */ diff --git a/src/core/lib/channel/channel_args.h b/src/core/lib/channel/channel_args.h index e19440f76f..67d287ec6b 100644 --- a/src/core/lib/channel/channel_args.h +++ b/src/core/lib/channel/channel_args.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CHANNEL_CHANNEL_ARGS_H -#define GRPC_CORE_CHANNEL_CHANNEL_ARGS_H +#ifndef GRPC_CORE_LIB_CHANNEL_CHANNEL_ARGS_H +#define GRPC_CORE_LIB_CHANNEL_CHANNEL_ARGS_H #include #include @@ -91,4 +91,4 @@ int grpc_channel_args_compression_algorithm_get_states( int grpc_channel_args_compare(const grpc_channel_args *a, const grpc_channel_args *b); -#endif /* GRPC_CORE_CHANNEL_CHANNEL_ARGS_H */ +#endif /* GRPC_CORE_LIB_CHANNEL_CHANNEL_ARGS_H */ diff --git a/src/core/lib/channel/channel_stack.h b/src/core/lib/channel/channel_stack.h index 52362f0b20..d91a65cb70 100644 --- a/src/core/lib/channel/channel_stack.h +++ b/src/core/lib/channel/channel_stack.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CHANNEL_CHANNEL_STACK_H -#define GRPC_CORE_CHANNEL_CHANNEL_STACK_H +#ifndef GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_H +#define GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_H /* A channel filter defines how operations on a channel are implemented. Channel filters are chained together to create full channels, and if those @@ -257,4 +257,4 @@ extern int grpc_trace_channel; #define GRPC_CALL_LOG_OP(sev, elem, op) \ if (grpc_trace_channel) grpc_call_log_op(sev, elem, op) -#endif /* GRPC_CORE_CHANNEL_CHANNEL_STACK_H */ +#endif /* GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_H */ diff --git a/src/core/lib/channel/channel_stack_builder.h b/src/core/lib/channel/channel_stack_builder.h index 15f395e8b8..ca285a9b23 100644 --- a/src/core/lib/channel/channel_stack_builder.h +++ b/src/core/lib/channel/channel_stack_builder.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CHANNEL_CHANNEL_STACK_BUILDER_H -#define GRPC_CORE_CHANNEL_CHANNEL_STACK_BUILDER_H +#ifndef GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H +#define GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H #include @@ -152,4 +152,4 @@ void grpc_channel_stack_builder_destroy(grpc_channel_stack_builder *builder); extern int grpc_trace_channel_stack_builder; -#endif /* GRPC_CORE_CHANNEL_CHANNEL_STACK_BUILDER_H */ +#endif /* GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H */ diff --git a/src/core/lib/channel/client_channel.h b/src/core/lib/channel/client_channel.h index 422f7f8374..dacdd3bb69 100644 --- a/src/core/lib/channel/client_channel.h +++ b/src/core/lib/channel/client_channel.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CHANNEL_CLIENT_CHANNEL_H -#define GRPC_CORE_CHANNEL_CLIENT_CHANNEL_H +#ifndef GRPC_CORE_LIB_CHANNEL_CLIENT_CHANNEL_H +#define GRPC_CORE_LIB_CHANNEL_CLIENT_CHANNEL_H #include "src/core/channel/channel_stack.h" #include "src/core/client_config/resolver.h" @@ -60,4 +60,4 @@ void grpc_client_channel_watch_connectivity_state( grpc_exec_ctx *exec_ctx, grpc_channel_element *elem, grpc_pollset *pollset, grpc_connectivity_state *state, grpc_closure *on_complete); -#endif /* GRPC_CORE_CHANNEL_CLIENT_CHANNEL_H */ +#endif /* GRPC_CORE_LIB_CHANNEL_CLIENT_CHANNEL_H */ diff --git a/src/core/lib/channel/compress_filter.h b/src/core/lib/channel/compress_filter.h index 8c208ac799..73eb271731 100644 --- a/src/core/lib/channel/compress_filter.h +++ b/src/core/lib/channel/compress_filter.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CHANNEL_COMPRESS_FILTER_H -#define GRPC_CORE_CHANNEL_COMPRESS_FILTER_H +#ifndef GRPC_CORE_LIB_CHANNEL_COMPRESS_FILTER_H +#define GRPC_CORE_LIB_CHANNEL_COMPRESS_FILTER_H #include "src/core/channel/channel_stack.h" @@ -62,4 +62,4 @@ extern const grpc_channel_filter grpc_compress_filter; -#endif /* GRPC_CORE_CHANNEL_COMPRESS_FILTER_H */ +#endif /* GRPC_CORE_LIB_CHANNEL_COMPRESS_FILTER_H */ diff --git a/src/core/lib/channel/connected_channel.h b/src/core/lib/channel/connected_channel.h index 7c0c8359a4..971bc913bc 100644 --- a/src/core/lib/channel/connected_channel.h +++ b/src/core/lib/channel/connected_channel.h @@ -31,12 +31,12 @@ * */ -#ifndef GRPC_CORE_CHANNEL_CONNECTED_CHANNEL_H -#define GRPC_CORE_CHANNEL_CONNECTED_CHANNEL_H +#ifndef GRPC_CORE_LIB_CHANNEL_CONNECTED_CHANNEL_H +#define GRPC_CORE_LIB_CHANNEL_CONNECTED_CHANNEL_H #include "src/core/channel/channel_stack_builder.h" bool grpc_add_connected_filter(grpc_channel_stack_builder *builder, void *arg_must_be_null); -#endif /* GRPC_CORE_CHANNEL_CONNECTED_CHANNEL_H */ +#endif /* GRPC_CORE_LIB_CHANNEL_CONNECTED_CHANNEL_H */ diff --git a/src/core/lib/channel/context.h b/src/core/lib/channel/context.h index db217dc133..bca102da9a 100644 --- a/src/core/lib/channel/context.h +++ b/src/core/lib/channel/context.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CHANNEL_CONTEXT_H -#define GRPC_CORE_CHANNEL_CONTEXT_H +#ifndef GRPC_CORE_LIB_CHANNEL_CONTEXT_H +#define GRPC_CORE_LIB_CHANNEL_CONTEXT_H /* Call object context pointers */ typedef enum { @@ -46,4 +46,4 @@ typedef struct { void (*destroy)(void *); } grpc_call_context_element; -#endif /* GRPC_CORE_CHANNEL_CONTEXT_H */ +#endif /* GRPC_CORE_LIB_CHANNEL_CONTEXT_H */ diff --git a/src/core/lib/channel/http_client_filter.h b/src/core/lib/channel/http_client_filter.h index 6f619bbf00..d2ccdda0a4 100644 --- a/src/core/lib/channel/http_client_filter.h +++ b/src/core/lib/channel/http_client_filter.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CHANNEL_HTTP_CLIENT_FILTER_H -#define GRPC_CORE_CHANNEL_HTTP_CLIENT_FILTER_H +#ifndef GRPC_CORE_LIB_CHANNEL_HTTP_CLIENT_FILTER_H +#define GRPC_CORE_LIB_CHANNEL_HTTP_CLIENT_FILTER_H #include "src/core/channel/channel_stack.h" @@ -41,4 +41,4 @@ extern const grpc_channel_filter grpc_http_client_filter; #define GRPC_ARG_HTTP2_SCHEME "grpc.http2_scheme" -#endif /* GRPC_CORE_CHANNEL_HTTP_CLIENT_FILTER_H */ +#endif /* GRPC_CORE_LIB_CHANNEL_HTTP_CLIENT_FILTER_H */ diff --git a/src/core/lib/channel/http_server_filter.h b/src/core/lib/channel/http_server_filter.h index 528c8648fd..3e6f5782bc 100644 --- a/src/core/lib/channel/http_server_filter.h +++ b/src/core/lib/channel/http_server_filter.h @@ -31,12 +31,12 @@ * */ -#ifndef GRPC_CORE_CHANNEL_HTTP_SERVER_FILTER_H -#define GRPC_CORE_CHANNEL_HTTP_SERVER_FILTER_H +#ifndef GRPC_CORE_LIB_CHANNEL_HTTP_SERVER_FILTER_H +#define GRPC_CORE_LIB_CHANNEL_HTTP_SERVER_FILTER_H #include "src/core/channel/channel_stack.h" /* Processes metadata on the client side for HTTP2 transports */ extern const grpc_channel_filter grpc_http_server_filter; -#endif /* GRPC_CORE_CHANNEL_HTTP_SERVER_FILTER_H */ +#endif /* GRPC_CORE_LIB_CHANNEL_HTTP_SERVER_FILTER_H */ diff --git a/src/core/lib/channel/subchannel_call_holder.h b/src/core/lib/channel/subchannel_call_holder.h index 84b4657db4..17b4910ac5 100644 --- a/src/core/lib/channel/subchannel_call_holder.h +++ b/src/core/lib/channel/subchannel_call_holder.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CHANNEL_SUBCHANNEL_CALL_HOLDER_H -#define GRPC_CORE_CHANNEL_SUBCHANNEL_CALL_HOLDER_H +#ifndef GRPC_CORE_LIB_CHANNEL_SUBCHANNEL_CALL_HOLDER_H +#define GRPC_CORE_LIB_CHANNEL_SUBCHANNEL_CALL_HOLDER_H #include "src/core/client_config/subchannel.h" @@ -94,4 +94,4 @@ void grpc_subchannel_call_holder_perform_op(grpc_exec_ctx *exec_ctx, char *grpc_subchannel_call_holder_get_peer(grpc_exec_ctx *exec_ctx, grpc_subchannel_call_holder *holder); -#endif /* GRPC_CORE_CHANNEL_SUBCHANNEL_CALL_HOLDER_H */ +#endif /* GRPC_CORE_LIB_CHANNEL_SUBCHANNEL_CALL_HOLDER_H */ diff --git a/src/core/lib/client_config/client_config.h b/src/core/lib/client_config/client_config.h index 9b37fdc211..c2b5eb7bf3 100644 --- a/src/core/lib/client_config/client_config.h +++ b/src/core/lib/client_config/client_config.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_CLIENT_CONFIG_H -#define GRPC_CORE_CLIENT_CONFIG_CLIENT_CONFIG_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_CLIENT_CONFIG_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_CLIENT_CONFIG_H #include "src/core/client_config/lb_policy.h" @@ -50,4 +50,4 @@ void grpc_client_config_set_lb_policy(grpc_client_config *client_config, grpc_lb_policy *grpc_client_config_get_lb_policy( grpc_client_config *client_config); -#endif /* GRPC_CORE_CLIENT_CONFIG_CLIENT_CONFIG_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_CLIENT_CONFIG_H */ diff --git a/src/core/lib/client_config/connector.h b/src/core/lib/client_config/connector.h index 93248fca4b..34a7c26bae 100644 --- a/src/core/lib/client_config/connector.h +++ b/src/core/lib/client_config/connector.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_CONNECTOR_H -#define GRPC_CORE_CLIENT_CONFIG_CONNECTOR_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_CONNECTOR_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_CONNECTOR_H #include "src/core/channel/channel_stack.h" #include "src/core/iomgr/sockaddr.h" @@ -89,4 +89,4 @@ void grpc_connector_connect(grpc_exec_ctx *exec_ctx, grpc_connector *connector, void grpc_connector_shutdown(grpc_exec_ctx *exec_ctx, grpc_connector *connector); -#endif /* GRPC_CORE_CLIENT_CONFIG_CONNECTOR_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_CONNECTOR_H */ diff --git a/src/core/lib/client_config/initial_connect_string.h b/src/core/lib/client_config/initial_connect_string.h index e6d2d8f8fe..ce8096a28a 100644 --- a/src/core/lib/client_config/initial_connect_string.h +++ b/src/core/lib/client_config/initial_connect_string.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_INITIAL_CONNECT_STRING_H -#define GRPC_CORE_CLIENT_CONFIG_INITIAL_CONNECT_STRING_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_INITIAL_CONNECT_STRING_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_INITIAL_CONNECT_STRING_H #include #include "src/core/iomgr/sockaddr.h" @@ -47,4 +47,4 @@ void grpc_test_set_initial_connect_string_function( void grpc_set_initial_connect_string(struct sockaddr **addr, size_t *addr_len, gpr_slice *connect_string); -#endif /* GRPC_CORE_CLIENT_CONFIG_INITIAL_CONNECT_STRING_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_INITIAL_CONNECT_STRING_H */ diff --git a/src/core/lib/client_config/lb_policies/load_balancer_api.h b/src/core/lib/client_config/lb_policies/load_balancer_api.h index b7a4c9c8f5..b0ccfaff1f 100644 --- a/src/core/lib/client_config/lb_policies/load_balancer_api.h +++ b/src/core/lib/client_config/lb_policies/load_balancer_api.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_LOAD_BALANCER_API_H -#define GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_LOAD_BALANCER_API_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICIES_LOAD_BALANCER_API_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICIES_LOAD_BALANCER_API_H #include @@ -82,4 +82,4 @@ void grpc_grpclb_response_destroy(grpc_grpclb_response *response); } #endif -#endif /* GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_LOAD_BALANCER_API_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICIES_LOAD_BALANCER_API_H */ diff --git a/src/core/lib/client_config/lb_policies/pick_first.h b/src/core/lib/client_config/lb_policies/pick_first.h index 3a3f195df5..141d354fd2 100644 --- a/src/core/lib/client_config/lb_policies/pick_first.h +++ b/src/core/lib/client_config/lb_policies/pick_first.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_PICK_FIRST_H -#define GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_PICK_FIRST_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICIES_PICK_FIRST_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICIES_PICK_FIRST_H #include "src/core/client_config/lb_policy_factory.h" @@ -40,4 +40,4 @@ * the first subchannel from \a subchannels to succesfully connect */ grpc_lb_policy_factory *grpc_pick_first_lb_factory_create(); -#endif /* GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_PICK_FIRST_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICIES_PICK_FIRST_H */ diff --git a/src/core/lib/client_config/lb_policies/round_robin.h b/src/core/lib/client_config/lb_policies/round_robin.h index 7e6f1769e4..2f01147897 100644 --- a/src/core/lib/client_config/lb_policies/round_robin.h +++ b/src/core/lib/client_config/lb_policies/round_robin.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_ROUND_ROBIN_H -#define GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_ROUND_ROBIN_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICIES_ROUND_ROBIN_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICIES_ROUND_ROBIN_H #include "src/core/client_config/lb_policy.h" @@ -43,4 +43,4 @@ extern int grpc_lb_round_robin_trace; /** Returns a load balancing factory for the round robin policy */ grpc_lb_policy_factory *grpc_round_robin_lb_factory_create(); -#endif /* GRPC_CORE_CLIENT_CONFIG_LB_POLICIES_ROUND_ROBIN_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICIES_ROUND_ROBIN_H */ diff --git a/src/core/lib/client_config/lb_policy.h b/src/core/lib/client_config/lb_policy.h index ffebc2a69c..2ccd314d51 100644 --- a/src/core/lib/client_config/lb_policy.h +++ b/src/core/lib/client_config/lb_policy.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_LB_POLICY_H -#define GRPC_CORE_CLIENT_CONFIG_LB_POLICY_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_H #include "src/core/client_config/subchannel.h" #include "src/core/transport/connectivity_state.h" @@ -141,4 +141,4 @@ void grpc_lb_policy_notify_on_state_change(grpc_exec_ctx *exec_ctx, grpc_connectivity_state grpc_lb_policy_check_connectivity( grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy); -#endif /* GRPC_CORE_CLIENT_CONFIG_LB_POLICY_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_H */ diff --git a/src/core/lib/client_config/lb_policy_factory.h b/src/core/lib/client_config/lb_policy_factory.h index 842ba96098..41eabadefa 100644 --- a/src/core/lib/client_config/lb_policy_factory.h +++ b/src/core/lib/client_config/lb_policy_factory.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_LB_POLICY_FACTORY_H -#define GRPC_CORE_CLIENT_CONFIG_LB_POLICY_FACTORY_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_FACTORY_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_FACTORY_H #include "src/core/client_config/lb_policy.h" #include "src/core/client_config/subchannel.h" @@ -70,4 +70,4 @@ void grpc_lb_policy_factory_unref(grpc_lb_policy_factory *factory); grpc_lb_policy *grpc_lb_policy_factory_create_lb_policy( grpc_lb_policy_factory *factory, grpc_lb_policy_args *args); -#endif /* GRPC_CORE_CLIENT_CONFIG_LB_POLICY_FACTORY_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_FACTORY_H */ diff --git a/src/core/lib/client_config/lb_policy_registry.h b/src/core/lib/client_config/lb_policy_registry.h index f3a08a3558..bc82371bbe 100644 --- a/src/core/lib/client_config/lb_policy_registry.h +++ b/src/core/lib/client_config/lb_policy_registry.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_LB_POLICY_REGISTRY_H -#define GRPC_CORE_CLIENT_CONFIG_LB_POLICY_REGISTRY_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_REGISTRY_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_REGISTRY_H #include "src/core/client_config/lb_policy_factory.h" @@ -51,4 +51,4 @@ void grpc_register_lb_policy(grpc_lb_policy_factory *factory); grpc_lb_policy *grpc_lb_policy_create(const char *name, grpc_lb_policy_args *args); -#endif /* GRPC_CORE_CLIENT_CONFIG_LB_POLICY_REGISTRY_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_REGISTRY_H */ diff --git a/src/core/lib/client_config/resolver.h b/src/core/lib/client_config/resolver.h index 96f88fef84..358f73fa27 100644 --- a/src/core/lib/client_config/resolver.h +++ b/src/core/lib/client_config/resolver.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_RESOLVER_H -#define GRPC_CORE_CLIENT_CONFIG_RESOLVER_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_H #include "src/core/client_config/client_config.h" #include "src/core/client_config/subchannel.h" @@ -91,4 +91,4 @@ void grpc_resolver_next(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver, grpc_client_config **target_config, grpc_closure *on_complete); -#endif /* GRPC_CORE_CLIENT_CONFIG_RESOLVER_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_H */ diff --git a/src/core/lib/client_config/resolver_factory.h b/src/core/lib/client_config/resolver_factory.h index 477f8db7f7..3d309c85f8 100644 --- a/src/core/lib/client_config/resolver_factory.h +++ b/src/core/lib/client_config/resolver_factory.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_RESOLVER_FACTORY_H -#define GRPC_CORE_CLIENT_CONFIG_RESOLVER_FACTORY_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_FACTORY_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_FACTORY_H #include "src/core/client_config/resolver.h" #include "src/core/client_config/subchannel_factory.h" @@ -79,4 +79,4 @@ grpc_resolver *grpc_resolver_factory_create_resolver( char *grpc_resolver_factory_get_default_authority( grpc_resolver_factory *factory, grpc_uri *uri); -#endif /* GRPC_CORE_CLIENT_CONFIG_RESOLVER_FACTORY_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_FACTORY_H */ diff --git a/src/core/lib/client_config/resolver_registry.h b/src/core/lib/client_config/resolver_registry.h index 1e4cebee0b..72db20bf00 100644 --- a/src/core/lib/client_config/resolver_registry.h +++ b/src/core/lib/client_config/resolver_registry.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_RESOLVER_REGISTRY_H -#define GRPC_CORE_CLIENT_CONFIG_RESOLVER_REGISTRY_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_REGISTRY_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_REGISTRY_H #include "src/core/client_config/resolver_factory.h" @@ -62,4 +62,4 @@ grpc_resolver *grpc_resolver_create( representing the default authority to pass from a client. */ char *grpc_get_default_authority(const char *target); -#endif /* GRPC_CORE_CLIENT_CONFIG_RESOLVER_REGISTRY_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_REGISTRY_H */ diff --git a/src/core/lib/client_config/resolvers/dns_resolver.h b/src/core/lib/client_config/resolvers/dns_resolver.h index b24280b507..7dada84278 100644 --- a/src/core/lib/client_config/resolvers/dns_resolver.h +++ b/src/core/lib/client_config/resolvers/dns_resolver.h @@ -31,12 +31,12 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_RESOLVERS_DNS_RESOLVER_H -#define GRPC_CORE_CLIENT_CONFIG_RESOLVERS_DNS_RESOLVER_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVERS_DNS_RESOLVER_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVERS_DNS_RESOLVER_H #include "src/core/client_config/resolver_factory.h" /** Create a dns resolver factory */ grpc_resolver_factory *grpc_dns_resolver_factory_create(void); -#endif /* GRPC_CORE_CLIENT_CONFIG_RESOLVERS_DNS_RESOLVER_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVERS_DNS_RESOLVER_H */ diff --git a/src/core/lib/client_config/resolvers/sockaddr_resolver.h b/src/core/lib/client_config/resolvers/sockaddr_resolver.h index f050329431..3bbcf1dd81 100644 --- a/src/core/lib/client_config/resolvers/sockaddr_resolver.h +++ b/src/core/lib/client_config/resolvers/sockaddr_resolver.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_RESOLVERS_SOCKADDR_RESOLVER_H -#define GRPC_CORE_CLIENT_CONFIG_RESOLVERS_SOCKADDR_RESOLVER_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVERS_SOCKADDR_RESOLVER_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVERS_SOCKADDR_RESOLVER_H #include @@ -47,4 +47,4 @@ grpc_resolver_factory *grpc_ipv6_resolver_factory_create(void); grpc_resolver_factory *grpc_unix_resolver_factory_create(void); #endif -#endif /* GRPC_CORE_CLIENT_CONFIG_RESOLVERS_SOCKADDR_RESOLVER_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVERS_SOCKADDR_RESOLVER_H */ diff --git a/src/core/lib/client_config/resolvers/zookeeper_resolver.h b/src/core/lib/client_config/resolvers/zookeeper_resolver.h index 04bd3ca875..603097e5f8 100644 --- a/src/core/lib/client_config/resolvers/zookeeper_resolver.h +++ b/src/core/lib/client_config/resolvers/zookeeper_resolver.h @@ -31,12 +31,12 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_RESOLVERS_ZOOKEEPER_RESOLVER_H -#define GRPC_CORE_CLIENT_CONFIG_RESOLVERS_ZOOKEEPER_RESOLVER_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVERS_ZOOKEEPER_RESOLVER_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVERS_ZOOKEEPER_RESOLVER_H #include "src/core/client_config/resolver_factory.h" /** Create a zookeeper resolver factory */ grpc_resolver_factory *grpc_zookeeper_resolver_factory_create(void); -#endif /* GRPC_CORE_CLIENT_CONFIG_RESOLVERS_ZOOKEEPER_RESOLVER_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVERS_ZOOKEEPER_RESOLVER_H */ diff --git a/src/core/lib/client_config/subchannel.h b/src/core/lib/client_config/subchannel.h index 83e1c58a4c..a8fcbe7b0e 100644 --- a/src/core/lib/client_config/subchannel.h +++ b/src/core/lib/client_config/subchannel.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_H -#define GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_H #include "src/core/channel/channel_stack.h" #include "src/core/client_config/connector.h" @@ -171,4 +171,4 @@ grpc_subchannel *grpc_subchannel_create(grpc_exec_ctx *exec_ctx, grpc_connector *connector, grpc_subchannel_args *args); -#endif /* GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_H */ diff --git a/src/core/lib/client_config/subchannel_factory.h b/src/core/lib/client_config/subchannel_factory.h index c638f377a6..1017b13fcd 100644 --- a/src/core/lib/client_config/subchannel_factory.h +++ b/src/core/lib/client_config/subchannel_factory.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_FACTORY_H -#define GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_FACTORY_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_FACTORY_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_FACTORY_H #include "src/core/channel/channel_stack.h" #include "src/core/client_config/subchannel.h" @@ -63,4 +63,4 @@ grpc_subchannel *grpc_subchannel_factory_create_subchannel( grpc_exec_ctx *exec_ctx, grpc_subchannel_factory *factory, grpc_subchannel_args *args); -#endif /* GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_FACTORY_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_FACTORY_H */ diff --git a/src/core/lib/client_config/subchannel_index.h b/src/core/lib/client_config/subchannel_index.h index 3cd5d12349..f5627dfaf7 100644 --- a/src/core/lib/client_config/subchannel_index.h +++ b/src/core/lib/client_config/subchannel_index.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_INDEX_H -#define GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_INDEX_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_INDEX_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_INDEX_H #include "src/core/client_config/connector.h" #include "src/core/client_config/subchannel.h" @@ -74,4 +74,4 @@ void grpc_subchannel_index_init(void); /** Shutdown the subchannel index (global) */ void grpc_subchannel_index_shutdown(void); -#endif /* GRPC_CORE_CLIENT_CONFIG_SUBCHANNEL_INDEX_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_INDEX_H */ diff --git a/src/core/lib/client_config/uri_parser.h b/src/core/lib/client_config/uri_parser.h index af013d8cac..d70d451e60 100644 --- a/src/core/lib/client_config/uri_parser.h +++ b/src/core/lib/client_config/uri_parser.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_CLIENT_CONFIG_URI_PARSER_H -#define GRPC_CORE_CLIENT_CONFIG_URI_PARSER_H +#ifndef GRPC_CORE_LIB_CLIENT_CONFIG_URI_PARSER_H +#define GRPC_CORE_LIB_CLIENT_CONFIG_URI_PARSER_H typedef struct { char *scheme; @@ -48,4 +48,4 @@ grpc_uri *grpc_uri_parse(const char *uri_text, int suppress_errors); /** destroy a uri */ void grpc_uri_destroy(grpc_uri *uri); -#endif /* GRPC_CORE_CLIENT_CONFIG_URI_PARSER_H */ +#endif /* GRPC_CORE_LIB_CLIENT_CONFIG_URI_PARSER_H */ diff --git a/src/core/lib/compression/algorithm_metadata.h b/src/core/lib/compression/algorithm_metadata.h index 34abf1dba2..6ebde1e8fd 100644 --- a/src/core/lib/compression/algorithm_metadata.h +++ b/src/core/lib/compression/algorithm_metadata.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_COMPRESSION_ALGORITHM_METADATA_H -#define GRPC_CORE_COMPRESSION_ALGORITHM_METADATA_H +#ifndef GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_H +#define GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_H #include #include "src/core/transport/metadata.h" @@ -50,4 +50,4 @@ grpc_mdelem *grpc_compression_encoding_mdelem( grpc_compression_algorithm grpc_compression_algorithm_from_mdstr( grpc_mdstr *str); -#endif /* GRPC_CORE_COMPRESSION_ALGORITHM_METADATA_H */ +#endif /* GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_H */ diff --git a/src/core/lib/compression/message_compress.h b/src/core/lib/compression/message_compress.h index 20b78c063b..b71608139e 100644 --- a/src/core/lib/compression/message_compress.h +++ b/src/core/lib/compression/message_compress.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_COMPRESSION_MESSAGE_COMPRESS_H -#define GRPC_CORE_COMPRESSION_MESSAGE_COMPRESS_H +#ifndef GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H +#define GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H #include #include @@ -49,4 +49,4 @@ int grpc_msg_compress(grpc_compression_algorithm algorithm, int grpc_msg_decompress(grpc_compression_algorithm algorithm, gpr_slice_buffer* input, gpr_slice_buffer* output); -#endif /* GRPC_CORE_COMPRESSION_MESSAGE_COMPRESS_H */ +#endif /* GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H */ diff --git a/src/core/lib/debug/trace.h b/src/core/lib/debug/trace.h index 91ec14052e..76ea5a7c64 100644 --- a/src/core/lib/debug/trace.h +++ b/src/core/lib/debug/trace.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_DEBUG_TRACE_H -#define GRPC_CORE_DEBUG_TRACE_H +#ifndef GRPC_CORE_LIB_DEBUG_TRACE_H +#define GRPC_CORE_LIB_DEBUG_TRACE_H #include @@ -40,4 +40,4 @@ void grpc_register_tracer(const char *name, int *flag); void grpc_tracer_init(const char *env_var_name); void grpc_tracer_shutdown(void); -#endif /* GRPC_CORE_DEBUG_TRACE_H */ +#endif /* GRPC_CORE_LIB_DEBUG_TRACE_H */ diff --git a/src/core/lib/http/format_request.h b/src/core/lib/http/format_request.h index dfd6fadbde..eb8e3267b6 100644 --- a/src/core/lib/http/format_request.h +++ b/src/core/lib/http/format_request.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_HTTP_FORMAT_REQUEST_H -#define GRPC_CORE_HTTP_FORMAT_REQUEST_H +#ifndef GRPC_CORE_LIB_HTTP_FORMAT_REQUEST_H +#define GRPC_CORE_LIB_HTTP_FORMAT_REQUEST_H #include #include "src/core/http/httpcli.h" @@ -42,4 +42,4 @@ gpr_slice grpc_httpcli_format_post_request(const grpc_httpcli_request *request, const char *body_bytes, size_t body_size); -#endif /* GRPC_CORE_HTTP_FORMAT_REQUEST_H */ +#endif /* GRPC_CORE_LIB_HTTP_FORMAT_REQUEST_H */ diff --git a/src/core/lib/http/httpcli.h b/src/core/lib/http/httpcli.h index 0bf4f2f445..f28d6d7481 100644 --- a/src/core/lib/http/httpcli.h +++ b/src/core/lib/http/httpcli.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_HTTP_HTTPCLI_H -#define GRPC_CORE_HTTP_HTTPCLI_H +#ifndef GRPC_CORE_LIB_HTTP_HTTPCLI_H +#define GRPC_CORE_LIB_HTTP_HTTPCLI_H #include @@ -141,4 +141,4 @@ typedef int (*grpc_httpcli_post_override)( void grpc_httpcli_set_override(grpc_httpcli_get_override get, grpc_httpcli_post_override post); -#endif /* GRPC_CORE_HTTP_HTTPCLI_H */ +#endif /* GRPC_CORE_LIB_HTTP_HTTPCLI_H */ diff --git a/src/core/lib/http/parser.h b/src/core/lib/http/parser.h index 39517e485a..6a72174aa6 100644 --- a/src/core/lib/http/parser.h +++ b/src/core/lib/http/parser.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_HTTP_PARSER_H -#define GRPC_CORE_HTTP_PARSER_H +#ifndef GRPC_CORE_LIB_HTTP_PARSER_H +#define GRPC_CORE_LIB_HTTP_PARSER_H #include #include @@ -113,4 +113,4 @@ void grpc_http_parser_destroy(grpc_http_parser *parser); int grpc_http_parser_parse(grpc_http_parser *parser, gpr_slice slice); int grpc_http_parser_eof(grpc_http_parser *parser); -#endif /* GRPC_CORE_HTTP_PARSER_H */ +#endif /* GRPC_CORE_LIB_HTTP_PARSER_H */ diff --git a/src/core/lib/iomgr/closure.h b/src/core/lib/iomgr/closure.h index d5e1f455b9..2597cf1706 100644 --- a/src/core/lib/iomgr/closure.h +++ b/src/core/lib/iomgr/closure.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_CLOSURE_H -#define GRPC_CORE_IOMGR_CLOSURE_H +#ifndef GRPC_CORE_LIB_IOMGR_CLOSURE_H +#define GRPC_CORE_LIB_IOMGR_CLOSURE_H #include #include @@ -95,4 +95,4 @@ bool grpc_closure_list_empty(grpc_closure_list list); /** return the next pointer for a queued closure list */ grpc_closure *grpc_closure_next(grpc_closure *closure); -#endif /* GRPC_CORE_IOMGR_CLOSURE_H */ +#endif /* GRPC_CORE_LIB_IOMGR_CLOSURE_H */ diff --git a/src/core/lib/iomgr/endpoint.h b/src/core/lib/iomgr/endpoint.h index b4be852e33..740ec50c6a 100644 --- a/src/core/lib/iomgr/endpoint.h +++ b/src/core/lib/iomgr/endpoint.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_ENDPOINT_H -#define GRPC_CORE_IOMGR_ENDPOINT_H +#ifndef GRPC_CORE_LIB_IOMGR_ENDPOINT_H +#define GRPC_CORE_LIB_IOMGR_ENDPOINT_H #include #include @@ -99,4 +99,4 @@ struct grpc_endpoint { const grpc_endpoint_vtable *vtable; }; -#endif /* GRPC_CORE_IOMGR_ENDPOINT_H */ +#endif /* GRPC_CORE_LIB_IOMGR_ENDPOINT_H */ diff --git a/src/core/lib/iomgr/endpoint_pair.h b/src/core/lib/iomgr/endpoint_pair.h index 59015d8ffb..39af04c9df 100644 --- a/src/core/lib/iomgr/endpoint_pair.h +++ b/src/core/lib/iomgr/endpoint_pair.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_ENDPOINT_PAIR_H -#define GRPC_CORE_IOMGR_ENDPOINT_PAIR_H +#ifndef GRPC_CORE_LIB_IOMGR_ENDPOINT_PAIR_H +#define GRPC_CORE_LIB_IOMGR_ENDPOINT_PAIR_H #include "src/core/iomgr/endpoint.h" @@ -44,4 +44,4 @@ typedef struct { grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char *name, size_t read_slice_size); -#endif /* GRPC_CORE_IOMGR_ENDPOINT_PAIR_H */ +#endif /* GRPC_CORE_LIB_IOMGR_ENDPOINT_PAIR_H */ diff --git a/src/core/lib/iomgr/exec_ctx.h b/src/core/lib/iomgr/exec_ctx.h index 07b54a0ab8..a6551cf1d4 100644 --- a/src/core/lib/iomgr/exec_ctx.h +++ b/src/core/lib/iomgr/exec_ctx.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_EXEC_CTX_H -#define GRPC_CORE_IOMGR_EXEC_CTX_H +#ifndef GRPC_CORE_LIB_IOMGR_EXEC_CTX_H +#define GRPC_CORE_LIB_IOMGR_EXEC_CTX_H #include "src/core/iomgr/closure.h" @@ -95,4 +95,4 @@ void grpc_exec_ctx_enqueue_list(grpc_exec_ctx *exec_ctx, void grpc_exec_ctx_global_init(void); void grpc_exec_ctx_global_shutdown(void); -#endif /* GRPC_CORE_IOMGR_EXEC_CTX_H */ +#endif /* GRPC_CORE_LIB_IOMGR_EXEC_CTX_H */ diff --git a/src/core/lib/iomgr/executor.h b/src/core/lib/iomgr/executor.h index f66b3560e3..7197c3f24a 100644 --- a/src/core/lib/iomgr/executor.h +++ b/src/core/lib/iomgr/executor.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_EXECUTOR_H -#define GRPC_CORE_IOMGR_EXECUTOR_H +#ifndef GRPC_CORE_LIB_IOMGR_EXECUTOR_H +#define GRPC_CORE_LIB_IOMGR_EXECUTOR_H #include "src/core/iomgr/closure.h" @@ -50,4 +50,4 @@ void grpc_executor_enqueue(grpc_closure *closure, bool success); /** Shutdown the executor, running all pending work as part of the call */ void grpc_executor_shutdown(); -#endif /* GRPC_CORE_IOMGR_EXECUTOR_H */ +#endif /* GRPC_CORE_LIB_IOMGR_EXECUTOR_H */ diff --git a/src/core/lib/iomgr/fd_posix.h b/src/core/lib/iomgr/fd_posix.h index 1993ada79f..a14c39f722 100644 --- a/src/core/lib/iomgr/fd_posix.h +++ b/src/core/lib/iomgr/fd_posix.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_FD_POSIX_H -#define GRPC_CORE_IOMGR_FD_POSIX_H +#ifndef GRPC_CORE_LIB_IOMGR_FD_POSIX_H +#define GRPC_CORE_LIB_IOMGR_FD_POSIX_H #include #include @@ -189,4 +189,4 @@ void grpc_fd_unref(grpc_fd *fd); void grpc_fd_global_init(void); void grpc_fd_global_shutdown(void); -#endif /* GRPC_CORE_IOMGR_FD_POSIX_H */ +#endif /* GRPC_CORE_LIB_IOMGR_FD_POSIX_H */ diff --git a/src/core/lib/iomgr/iocp_windows.h b/src/core/lib/iomgr/iocp_windows.h index 570b8925aa..9444dd4fce 100644 --- a/src/core/lib/iomgr/iocp_windows.h +++ b/src/core/lib/iomgr/iocp_windows.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_IOCP_WINDOWS_H -#define GRPC_CORE_IOMGR_IOCP_WINDOWS_H +#ifndef GRPC_CORE_LIB_IOMGR_IOCP_WINDOWS_H +#define GRPC_CORE_LIB_IOMGR_IOCP_WINDOWS_H #include @@ -60,4 +60,4 @@ void grpc_socket_notify_on_read(grpc_exec_ctx *exec_ctx, grpc_winsocket *winsocket, grpc_closure *closure); -#endif /* GRPC_CORE_IOMGR_IOCP_WINDOWS_H */ +#endif /* GRPC_CORE_LIB_IOMGR_IOCP_WINDOWS_H */ diff --git a/src/core/lib/iomgr/iomgr.h b/src/core/lib/iomgr/iomgr.h index e1237a4533..babf0a85b7 100644 --- a/src/core/lib/iomgr/iomgr.h +++ b/src/core/lib/iomgr/iomgr.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_IOMGR_H -#define GRPC_CORE_IOMGR_IOMGR_H +#ifndef GRPC_CORE_LIB_IOMGR_IOMGR_H +#define GRPC_CORE_LIB_IOMGR_IOMGR_H /** Initializes the iomgr. */ void grpc_iomgr_init(void); @@ -40,4 +40,4 @@ void grpc_iomgr_init(void); /** Signals the intention to shutdown the iomgr. */ void grpc_iomgr_shutdown(void); -#endif /* GRPC_CORE_IOMGR_IOMGR_H */ +#endif /* GRPC_CORE_LIB_IOMGR_IOMGR_H */ diff --git a/src/core/lib/iomgr/iomgr_internal.h b/src/core/lib/iomgr/iomgr_internal.h index 1cad3182ec..2aeee7f6ae 100644 --- a/src/core/lib/iomgr/iomgr_internal.h +++ b/src/core/lib/iomgr/iomgr_internal.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_IOMGR_INTERNAL_H -#define GRPC_CORE_IOMGR_IOMGR_INTERNAL_H +#ifndef GRPC_CORE_LIB_IOMGR_IOMGR_INTERNAL_H +#define GRPC_CORE_LIB_IOMGR_IOMGR_INTERNAL_H #include @@ -59,4 +59,4 @@ void grpc_iomgr_platform_shutdown(void); bool grpc_iomgr_abort_on_leaks(void); -#endif /* GRPC_CORE_IOMGR_IOMGR_INTERNAL_H */ +#endif /* GRPC_CORE_LIB_IOMGR_IOMGR_INTERNAL_H */ diff --git a/src/core/lib/iomgr/iomgr_posix.h b/src/core/lib/iomgr/iomgr_posix.h index 698fb6aee7..83fb082665 100644 --- a/src/core/lib/iomgr/iomgr_posix.h +++ b/src/core/lib/iomgr/iomgr_posix.h @@ -31,9 +31,9 @@ * */ -#ifndef GRPC_CORE_IOMGR_IOMGR_POSIX_H -#define GRPC_CORE_IOMGR_IOMGR_POSIX_H +#ifndef GRPC_CORE_LIB_IOMGR_IOMGR_POSIX_H +#define GRPC_CORE_LIB_IOMGR_IOMGR_POSIX_H #include "src/core/iomgr/iomgr_internal.h" -#endif /* GRPC_CORE_IOMGR_IOMGR_POSIX_H */ +#endif /* GRPC_CORE_LIB_IOMGR_IOMGR_POSIX_H */ diff --git a/src/core/lib/iomgr/pollset.h b/src/core/lib/iomgr/pollset.h index 9500b1a73a..db13f8ac69 100644 --- a/src/core/lib/iomgr/pollset.h +++ b/src/core/lib/iomgr/pollset.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_POLLSET_H -#define GRPC_CORE_IOMGR_POLLSET_H +#ifndef GRPC_CORE_LIB_IOMGR_POLLSET_H +#define GRPC_CORE_LIB_IOMGR_POLLSET_H #include #include @@ -91,4 +91,4 @@ void grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset, void grpc_pollset_kick(grpc_pollset *pollset, grpc_pollset_worker *specific_worker); -#endif /* GRPC_CORE_IOMGR_POLLSET_H */ +#endif /* GRPC_CORE_LIB_IOMGR_POLLSET_H */ diff --git a/src/core/lib/iomgr/pollset_posix.h b/src/core/lib/iomgr/pollset_posix.h index e0cfc44395..c4d1977a0b 100644 --- a/src/core/lib/iomgr/pollset_posix.h +++ b/src/core/lib/iomgr/pollset_posix.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_POLLSET_POSIX_H -#define GRPC_CORE_IOMGR_POLLSET_POSIX_H +#ifndef GRPC_CORE_LIB_IOMGR_POLLSET_POSIX_H +#define GRPC_CORE_LIB_IOMGR_POLLSET_POSIX_H #include @@ -150,4 +150,4 @@ typedef int (*grpc_poll_function_type)(struct pollfd *, nfds_t, int); extern grpc_poll_function_type grpc_poll_function; extern grpc_wakeup_fd grpc_global_wakeup_fd; -#endif /* GRPC_CORE_IOMGR_POLLSET_POSIX_H */ +#endif /* GRPC_CORE_LIB_IOMGR_POLLSET_POSIX_H */ diff --git a/src/core/lib/iomgr/pollset_set.h b/src/core/lib/iomgr/pollset_set.h index 204c625933..7af72a0297 100644 --- a/src/core/lib/iomgr/pollset_set.h +++ b/src/core/lib/iomgr/pollset_set.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_POLLSET_SET_H -#define GRPC_CORE_IOMGR_POLLSET_SET_H +#ifndef GRPC_CORE_LIB_IOMGR_POLLSET_SET_H +#define GRPC_CORE_LIB_IOMGR_POLLSET_SET_H #include "src/core/iomgr/pollset.h" @@ -58,4 +58,4 @@ void grpc_pollset_set_del_pollset_set(grpc_exec_ctx *exec_ctx, grpc_pollset_set *bag, grpc_pollset_set *item); -#endif /* GRPC_CORE_IOMGR_POLLSET_SET_H */ +#endif /* GRPC_CORE_LIB_IOMGR_POLLSET_SET_H */ diff --git a/src/core/lib/iomgr/pollset_set_posix.h b/src/core/lib/iomgr/pollset_set_posix.h index 80f487718e..db997e1bf0 100644 --- a/src/core/lib/iomgr/pollset_set_posix.h +++ b/src/core/lib/iomgr/pollset_set_posix.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_POLLSET_SET_POSIX_H -#define GRPC_CORE_IOMGR_POLLSET_SET_POSIX_H +#ifndef GRPC_CORE_LIB_IOMGR_POLLSET_SET_POSIX_H +#define GRPC_CORE_LIB_IOMGR_POLLSET_SET_POSIX_H #include "src/core/iomgr/fd_posix.h" #include "src/core/iomgr/pollset_set.h" @@ -42,4 +42,4 @@ void grpc_pollset_set_add_fd(grpc_exec_ctx *exec_ctx, void grpc_pollset_set_del_fd(grpc_exec_ctx *exec_ctx, grpc_pollset_set *pollset_set, grpc_fd *fd); -#endif /* GRPC_CORE_IOMGR_POLLSET_SET_POSIX_H */ +#endif /* GRPC_CORE_LIB_IOMGR_POLLSET_SET_POSIX_H */ diff --git a/src/core/lib/iomgr/pollset_set_windows.h b/src/core/lib/iomgr/pollset_set_windows.h index 0f040fef82..f0b37f8d21 100644 --- a/src/core/lib/iomgr/pollset_set_windows.h +++ b/src/core/lib/iomgr/pollset_set_windows.h @@ -31,9 +31,9 @@ * */ -#ifndef GRPC_CORE_IOMGR_POLLSET_SET_WINDOWS_H -#define GRPC_CORE_IOMGR_POLLSET_SET_WINDOWS_H +#ifndef GRPC_CORE_LIB_IOMGR_POLLSET_SET_WINDOWS_H +#define GRPC_CORE_LIB_IOMGR_POLLSET_SET_WINDOWS_H #include "src/core/iomgr/pollset_set.h" -#endif /* GRPC_CORE_IOMGR_POLLSET_SET_WINDOWS_H */ +#endif /* GRPC_CORE_LIB_IOMGR_POLLSET_SET_WINDOWS_H */ diff --git a/src/core/lib/iomgr/pollset_windows.h b/src/core/lib/iomgr/pollset_windows.h index f1d1585922..ff8e0a7b46 100644 --- a/src/core/lib/iomgr/pollset_windows.h +++ b/src/core/lib/iomgr/pollset_windows.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_POLLSET_WINDOWS_H -#define GRPC_CORE_IOMGR_POLLSET_WINDOWS_H +#ifndef GRPC_CORE_LIB_IOMGR_POLLSET_WINDOWS_H +#define GRPC_CORE_LIB_IOMGR_POLLSET_WINDOWS_H #include @@ -72,4 +72,4 @@ struct grpc_pollset { grpc_closure *on_shutdown; }; -#endif /* GRPC_CORE_IOMGR_POLLSET_WINDOWS_H */ +#endif /* GRPC_CORE_LIB_IOMGR_POLLSET_WINDOWS_H */ diff --git a/src/core/lib/iomgr/resolve_address.h b/src/core/lib/iomgr/resolve_address.h index aa0d7d194b..d3da7cc33e 100644 --- a/src/core/lib/iomgr/resolve_address.h +++ b/src/core/lib/iomgr/resolve_address.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_RESOLVE_ADDRESS_H -#define GRPC_CORE_IOMGR_RESOLVE_ADDRESS_H +#ifndef GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_H +#define GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_H #include #include "src/core/iomgr/exec_ctx.h" @@ -69,4 +69,4 @@ void grpc_resolved_addresses_destroy(grpc_resolved_addresses *addresses); extern grpc_resolved_addresses *(*grpc_blocking_resolve_address)( const char *name, const char *default_port); -#endif /* GRPC_CORE_IOMGR_RESOLVE_ADDRESS_H */ +#endif /* GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_H */ diff --git a/src/core/lib/iomgr/sockaddr.h b/src/core/lib/iomgr/sockaddr.h index 68241bdd55..e59a98e4ae 100644 --- a/src/core/lib/iomgr/sockaddr.h +++ b/src/core/lib/iomgr/sockaddr.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_SOCKADDR_H -#define GRPC_CORE_IOMGR_SOCKADDR_H +#ifndef GRPC_CORE_LIB_IOMGR_SOCKADDR_H +#define GRPC_CORE_LIB_IOMGR_SOCKADDR_H #include @@ -44,4 +44,4 @@ #include "src/core/iomgr/sockaddr_posix.h" #endif -#endif /* GRPC_CORE_IOMGR_SOCKADDR_H */ +#endif /* GRPC_CORE_LIB_IOMGR_SOCKADDR_H */ diff --git a/src/core/lib/iomgr/sockaddr_posix.h b/src/core/lib/iomgr/sockaddr_posix.h index a398096837..79a7467c5d 100644 --- a/src/core/lib/iomgr/sockaddr_posix.h +++ b/src/core/lib/iomgr/sockaddr_posix.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_SOCKADDR_POSIX_H -#define GRPC_CORE_IOMGR_SOCKADDR_POSIX_H +#ifndef GRPC_CORE_LIB_IOMGR_SOCKADDR_POSIX_H +#define GRPC_CORE_LIB_IOMGR_SOCKADDR_POSIX_H #include #include @@ -41,4 +41,4 @@ #include #include -#endif /* GRPC_CORE_IOMGR_SOCKADDR_POSIX_H */ +#endif /* GRPC_CORE_LIB_IOMGR_SOCKADDR_POSIX_H */ diff --git a/src/core/lib/iomgr/sockaddr_utils.h b/src/core/lib/iomgr/sockaddr_utils.h index 43dc7a45ec..58f30fca2b 100644 --- a/src/core/lib/iomgr/sockaddr_utils.h +++ b/src/core/lib/iomgr/sockaddr_utils.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_SOCKADDR_UTILS_H -#define GRPC_CORE_IOMGR_SOCKADDR_UTILS_H +#ifndef GRPC_CORE_LIB_IOMGR_SOCKADDR_UTILS_H +#define GRPC_CORE_LIB_IOMGR_SOCKADDR_UTILS_H #include "src/core/iomgr/sockaddr.h" @@ -86,4 +86,4 @@ int grpc_sockaddr_to_string(char **out, const struct sockaddr *addr, char *grpc_sockaddr_to_uri(const struct sockaddr *addr); -#endif /* GRPC_CORE_IOMGR_SOCKADDR_UTILS_H */ +#endif /* GRPC_CORE_LIB_IOMGR_SOCKADDR_UTILS_H */ diff --git a/src/core/lib/iomgr/sockaddr_win32.h b/src/core/lib/iomgr/sockaddr_win32.h index ef306e3cc3..2dd7111240 100644 --- a/src/core/lib/iomgr/sockaddr_win32.h +++ b/src/core/lib/iomgr/sockaddr_win32.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_SOCKADDR_WIN32_H -#define GRPC_CORE_IOMGR_SOCKADDR_WIN32_H +#ifndef GRPC_CORE_LIB_IOMGR_SOCKADDR_WIN32_H +#define GRPC_CORE_LIB_IOMGR_SOCKADDR_WIN32_H #include #include @@ -40,4 +40,4 @@ // must be included after the above #include -#endif /* GRPC_CORE_IOMGR_SOCKADDR_WIN32_H */ +#endif /* GRPC_CORE_LIB_IOMGR_SOCKADDR_WIN32_H */ diff --git a/src/core/lib/iomgr/socket_utils_posix.h b/src/core/lib/iomgr/socket_utils_posix.h index 3908550380..063f298d72 100644 --- a/src/core/lib/iomgr/socket_utils_posix.h +++ b/src/core/lib/iomgr/socket_utils_posix.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_SOCKET_UTILS_POSIX_H -#define GRPC_CORE_IOMGR_SOCKET_UTILS_POSIX_H +#ifndef GRPC_CORE_LIB_IOMGR_SOCKET_UTILS_POSIX_H +#define GRPC_CORE_LIB_IOMGR_SOCKET_UTILS_POSIX_H #include #include @@ -110,4 +110,4 @@ extern int grpc_forbid_dualstack_sockets_for_testing; int grpc_create_dualstack_socket(const struct sockaddr *addr, int type, int protocol, grpc_dualstack_mode *dsmode); -#endif /* GRPC_CORE_IOMGR_SOCKET_UTILS_POSIX_H */ +#endif /* GRPC_CORE_LIB_IOMGR_SOCKET_UTILS_POSIX_H */ diff --git a/src/core/lib/iomgr/socket_windows.h b/src/core/lib/iomgr/socket_windows.h index 6fe3c6e080..033aec695f 100644 --- a/src/core/lib/iomgr/socket_windows.h +++ b/src/core/lib/iomgr/socket_windows.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_SOCKET_WINDOWS_H -#define GRPC_CORE_IOMGR_SOCKET_WINDOWS_H +#ifndef GRPC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H +#define GRPC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H #include #include @@ -108,4 +108,4 @@ void grpc_winsocket_shutdown(grpc_winsocket *socket); /* Destroy a socket. Should only be called if there's no pending operation. */ void grpc_winsocket_destroy(grpc_winsocket *socket); -#endif /* GRPC_CORE_IOMGR_SOCKET_WINDOWS_H */ +#endif /* GRPC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H */ diff --git a/src/core/lib/iomgr/tcp_client.h b/src/core/lib/iomgr/tcp_client.h index c36f8de713..8f012e248c 100644 --- a/src/core/lib/iomgr/tcp_client.h +++ b/src/core/lib/iomgr/tcp_client.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_TCP_CLIENT_H -#define GRPC_CORE_IOMGR_TCP_CLIENT_H +#ifndef GRPC_CORE_LIB_IOMGR_TCP_CLIENT_H +#define GRPC_CORE_LIB_IOMGR_TCP_CLIENT_H #include #include "src/core/iomgr/endpoint.h" @@ -50,4 +50,4 @@ void grpc_tcp_client_connect(grpc_exec_ctx *exec_ctx, grpc_closure *on_connect, const struct sockaddr *addr, size_t addr_len, gpr_timespec deadline); -#endif /* GRPC_CORE_IOMGR_TCP_CLIENT_H */ +#endif /* GRPC_CORE_LIB_IOMGR_TCP_CLIENT_H */ diff --git a/src/core/lib/iomgr/tcp_posix.h b/src/core/lib/iomgr/tcp_posix.h index d846ec570f..b12fef5ecd 100644 --- a/src/core/lib/iomgr/tcp_posix.h +++ b/src/core/lib/iomgr/tcp_posix.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_TCP_POSIX_H -#define GRPC_CORE_IOMGR_TCP_POSIX_H +#ifndef GRPC_CORE_LIB_IOMGR_TCP_POSIX_H +#define GRPC_CORE_LIB_IOMGR_TCP_POSIX_H /* Low level TCP "bottom half" implementation, for use by transports built on top of a TCP connection. @@ -68,4 +68,4 @@ int grpc_tcp_fd(grpc_endpoint *ep); void grpc_tcp_destroy_and_release_fd(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep, int *fd, grpc_closure *done); -#endif /* GRPC_CORE_IOMGR_TCP_POSIX_H */ +#endif /* GRPC_CORE_LIB_IOMGR_TCP_POSIX_H */ diff --git a/src/core/lib/iomgr/tcp_server.h b/src/core/lib/iomgr/tcp_server.h index 93247e9e4e..e27fd233cd 100644 --- a/src/core/lib/iomgr/tcp_server.h +++ b/src/core/lib/iomgr/tcp_server.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_TCP_SERVER_H -#define GRPC_CORE_IOMGR_TCP_SERVER_H +#ifndef GRPC_CORE_LIB_IOMGR_TCP_SERVER_H +#define GRPC_CORE_LIB_IOMGR_TCP_SERVER_H #include "src/core/iomgr/closure.h" #include "src/core/iomgr/endpoint.h" @@ -100,4 +100,4 @@ void grpc_tcp_server_shutdown_starting_add(grpc_tcp_server *s, a call (exec_ctx!=NULL) to shutdown_complete. */ void grpc_tcp_server_unref(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s); -#endif /* GRPC_CORE_IOMGR_TCP_SERVER_H */ +#endif /* GRPC_CORE_LIB_IOMGR_TCP_SERVER_H */ diff --git a/src/core/lib/iomgr/tcp_windows.h b/src/core/lib/iomgr/tcp_windows.h index 78bc13389a..c9e508f296 100644 --- a/src/core/lib/iomgr/tcp_windows.h +++ b/src/core/lib/iomgr/tcp_windows.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_TCP_WINDOWS_H -#define GRPC_CORE_IOMGR_TCP_WINDOWS_H +#ifndef GRPC_CORE_LIB_IOMGR_TCP_WINDOWS_H +#define GRPC_CORE_LIB_IOMGR_TCP_WINDOWS_H /* Low level TCP "bottom half" implementation, for use by transports built on top of a TCP connection. @@ -54,4 +54,4 @@ grpc_endpoint *grpc_tcp_create(grpc_winsocket *socket, char *peer_string); int grpc_tcp_prepare_socket(SOCKET sock); -#endif /* GRPC_CORE_IOMGR_TCP_WINDOWS_H */ +#endif /* GRPC_CORE_LIB_IOMGR_TCP_WINDOWS_H */ diff --git a/src/core/lib/iomgr/time_averaged_stats.h b/src/core/lib/iomgr/time_averaged_stats.h index 048e244bcc..4a662e17ec 100644 --- a/src/core/lib/iomgr/time_averaged_stats.h +++ b/src/core/lib/iomgr/time_averaged_stats.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_TIME_AVERAGED_STATS_H -#define GRPC_CORE_IOMGR_TIME_AVERAGED_STATS_H +#ifndef GRPC_CORE_LIB_IOMGR_TIME_AVERAGED_STATS_H +#define GRPC_CORE_LIB_IOMGR_TIME_AVERAGED_STATS_H /* This tracks a time-decaying weighted average. It works by collecting batches of samples and then mixing their average into a time-decaying @@ -85,4 +85,4 @@ void grpc_time_averaged_stats_add_sample(grpc_time_averaged_stats* stats, value. */ double grpc_time_averaged_stats_update_average(grpc_time_averaged_stats* stats); -#endif /* GRPC_CORE_IOMGR_TIME_AVERAGED_STATS_H */ +#endif /* GRPC_CORE_LIB_IOMGR_TIME_AVERAGED_STATS_H */ diff --git a/src/core/lib/iomgr/timer.h b/src/core/lib/iomgr/timer.h index 1e2d1cbfbd..616a886743 100644 --- a/src/core/lib/iomgr/timer.h +++ b/src/core/lib/iomgr/timer.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_TIMER_H -#define GRPC_CORE_IOMGR_TIMER_H +#ifndef GRPC_CORE_LIB_IOMGR_TIMER_H +#define GRPC_CORE_LIB_IOMGR_TIMER_H #include #include @@ -105,4 +105,4 @@ void grpc_timer_list_shutdown(grpc_exec_ctx *exec_ctx); void grpc_kick_poller(void); -#endif /* GRPC_CORE_IOMGR_TIMER_H */ +#endif /* GRPC_CORE_LIB_IOMGR_TIMER_H */ diff --git a/src/core/lib/iomgr/timer_heap.h b/src/core/lib/iomgr/timer_heap.h index c2912ef45d..d6b4f083d8 100644 --- a/src/core/lib/iomgr/timer_heap.h +++ b/src/core/lib/iomgr/timer_heap.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_TIMER_HEAP_H -#define GRPC_CORE_IOMGR_TIMER_HEAP_H +#ifndef GRPC_CORE_LIB_IOMGR_TIMER_HEAP_H +#define GRPC_CORE_LIB_IOMGR_TIMER_HEAP_H #include "src/core/iomgr/timer.h" @@ -54,4 +54,4 @@ void grpc_timer_heap_pop(grpc_timer_heap *heap); int grpc_timer_heap_is_empty(grpc_timer_heap *heap); -#endif /* GRPC_CORE_IOMGR_TIMER_HEAP_H */ +#endif /* GRPC_CORE_LIB_IOMGR_TIMER_HEAP_H */ diff --git a/src/core/lib/iomgr/udp_server.h b/src/core/lib/iomgr/udp_server.h index 148c04fa9b..ac70124727 100644 --- a/src/core/lib/iomgr/udp_server.h +++ b/src/core/lib/iomgr/udp_server.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_UDP_SERVER_H -#define GRPC_CORE_IOMGR_UDP_SERVER_H +#ifndef GRPC_CORE_LIB_IOMGR_UDP_SERVER_H +#define GRPC_CORE_LIB_IOMGR_UDP_SERVER_H #include "src/core/iomgr/endpoint.h" #include "src/core/iomgr/fd_posix.h" @@ -74,4 +74,4 @@ int grpc_udp_server_add_port(grpc_udp_server *s, const void *addr, void grpc_udp_server_destroy(grpc_exec_ctx *exec_ctx, grpc_udp_server *server, grpc_closure *on_done); -#endif /* GRPC_CORE_IOMGR_UDP_SERVER_H */ +#endif /* GRPC_CORE_LIB_IOMGR_UDP_SERVER_H */ diff --git a/src/core/lib/iomgr/unix_sockets_posix.h b/src/core/lib/iomgr/unix_sockets_posix.h index e842ba3770..6382c92480 100644 --- a/src/core/lib/iomgr/unix_sockets_posix.h +++ b/src/core/lib/iomgr/unix_sockets_posix.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_UNIX_SOCKETS_POSIX_H -#define GRPC_CORE_IOMGR_UNIX_SOCKETS_POSIX_H +#ifndef GRPC_CORE_LIB_IOMGR_UNIX_SOCKETS_POSIX_H +#define GRPC_CORE_LIB_IOMGR_UNIX_SOCKETS_POSIX_H #include @@ -58,4 +58,4 @@ char *grpc_unix_get_default_authority(grpc_resolver_factory *factory, char *grpc_sockaddr_to_uri_unix_if_possible(const struct sockaddr *addr); -#endif /* GRPC_CORE_IOMGR_UNIX_SOCKETS_POSIX_H */ +#endif /* GRPC_CORE_LIB_IOMGR_UNIX_SOCKETS_POSIX_H */ diff --git a/src/core/lib/iomgr/wakeup_fd_pipe.h b/src/core/lib/iomgr/wakeup_fd_pipe.h index eb3e02b482..dd8275800a 100644 --- a/src/core/lib/iomgr/wakeup_fd_pipe.h +++ b/src/core/lib/iomgr/wakeup_fd_pipe.h @@ -31,11 +31,11 @@ * */ -#ifndef GRPC_CORE_IOMGR_WAKEUP_FD_PIPE_H -#define GRPC_CORE_IOMGR_WAKEUP_FD_PIPE_H +#ifndef GRPC_CORE_LIB_IOMGR_WAKEUP_FD_PIPE_H +#define GRPC_CORE_LIB_IOMGR_WAKEUP_FD_PIPE_H #include "src/core/iomgr/wakeup_fd_posix.h" extern grpc_wakeup_fd_vtable grpc_pipe_wakeup_fd_vtable; -#endif /* GRPC_CORE_IOMGR_WAKEUP_FD_PIPE_H */ +#endif /* GRPC_CORE_LIB_IOMGR_WAKEUP_FD_PIPE_H */ diff --git a/src/core/lib/iomgr/wakeup_fd_posix.h b/src/core/lib/iomgr/wakeup_fd_posix.h index d7e3cf4673..20988d5fd3 100644 --- a/src/core/lib/iomgr/wakeup_fd_posix.h +++ b/src/core/lib/iomgr/wakeup_fd_posix.h @@ -59,8 +59,8 @@ * 2. If the polling thread was awakened by a wakeup_fd event, call * grpc_wakeup_fd_consume_wakeup() on it. */ -#ifndef GRPC_CORE_IOMGR_WAKEUP_FD_POSIX_H -#define GRPC_CORE_IOMGR_WAKEUP_FD_POSIX_H +#ifndef GRPC_CORE_LIB_IOMGR_WAKEUP_FD_POSIX_H +#define GRPC_CORE_LIB_IOMGR_WAKEUP_FD_POSIX_H void grpc_wakeup_fd_global_init(void); void grpc_wakeup_fd_global_destroy(void); @@ -98,4 +98,4 @@ void grpc_wakeup_fd_destroy(grpc_wakeup_fd* fd_info); * wakeup_fd_nospecial.c if no such implementation exists. */ extern const grpc_wakeup_fd_vtable grpc_specialized_wakeup_fd_vtable; -#endif /* GRPC_CORE_IOMGR_WAKEUP_FD_POSIX_H */ +#endif /* GRPC_CORE_LIB_IOMGR_WAKEUP_FD_POSIX_H */ diff --git a/src/core/lib/iomgr/workqueue.h b/src/core/lib/iomgr/workqueue.h index 2b923ba152..d11fc77d82 100644 --- a/src/core/lib/iomgr/workqueue.h +++ b/src/core/lib/iomgr/workqueue.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_WORKQUEUE_H -#define GRPC_CORE_IOMGR_WORKQUEUE_H +#ifndef GRPC_CORE_LIB_IOMGR_WORKQUEUE_H +#define GRPC_CORE_LIB_IOMGR_WORKQUEUE_H #include "src/core/iomgr/closure.h" #include "src/core/iomgr/exec_ctx.h" @@ -80,4 +80,4 @@ void grpc_workqueue_add_to_pollset(grpc_exec_ctx *exec_ctx, void grpc_workqueue_push(grpc_workqueue *workqueue, grpc_closure *closure, int success); -#endif /* GRPC_CORE_IOMGR_WORKQUEUE_H */ +#endif /* GRPC_CORE_LIB_IOMGR_WORKQUEUE_H */ diff --git a/src/core/lib/iomgr/workqueue_posix.h b/src/core/lib/iomgr/workqueue_posix.h index 89937b1ea8..02e1dad44f 100644 --- a/src/core/lib/iomgr/workqueue_posix.h +++ b/src/core/lib/iomgr/workqueue_posix.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_IOMGR_WORKQUEUE_POSIX_H -#define GRPC_CORE_IOMGR_WORKQUEUE_POSIX_H +#ifndef GRPC_CORE_LIB_IOMGR_WORKQUEUE_POSIX_H +#define GRPC_CORE_LIB_IOMGR_WORKQUEUE_POSIX_H #include "src/core/iomgr/wakeup_fd_posix.h" @@ -50,4 +50,4 @@ struct grpc_workqueue { grpc_closure read_closure; }; -#endif /* GRPC_CORE_IOMGR_WORKQUEUE_POSIX_H */ +#endif /* GRPC_CORE_LIB_IOMGR_WORKQUEUE_POSIX_H */ diff --git a/src/core/lib/iomgr/workqueue_windows.h b/src/core/lib/iomgr/workqueue_windows.h index 7e8186921e..8e6980b6d9 100644 --- a/src/core/lib/iomgr/workqueue_windows.h +++ b/src/core/lib/iomgr/workqueue_windows.h @@ -31,7 +31,7 @@ * */ -#ifndef GRPC_CORE_IOMGR_WORKQUEUE_WINDOWS_H -#define GRPC_CORE_IOMGR_WORKQUEUE_WINDOWS_H +#ifndef GRPC_CORE_LIB_IOMGR_WORKQUEUE_WINDOWS_H +#define GRPC_CORE_LIB_IOMGR_WORKQUEUE_WINDOWS_H -#endif /* GRPC_CORE_IOMGR_WORKQUEUE_WINDOWS_H */ +#endif /* GRPC_CORE_LIB_IOMGR_WORKQUEUE_WINDOWS_H */ diff --git a/src/core/lib/json/json.h b/src/core/lib/json/json.h index aea9d5dadb..89d15846ce 100644 --- a/src/core/lib/json/json.h +++ b/src/core/lib/json/json.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_JSON_JSON_H -#define GRPC_CORE_JSON_JSON_H +#ifndef GRPC_CORE_LIB_JSON_JSON_H +#define GRPC_CORE_LIB_JSON_JSON_H #include @@ -85,4 +85,4 @@ char *grpc_json_dump_to_string(grpc_json *json, int indent); grpc_json *grpc_json_create(grpc_json_type type); void grpc_json_destroy(grpc_json *json); -#endif /* GRPC_CORE_JSON_JSON_H */ +#endif /* GRPC_CORE_LIB_JSON_JSON_H */ diff --git a/src/core/lib/json/json_common.h b/src/core/lib/json/json_common.h index 7205a94685..ce980040f8 100644 --- a/src/core/lib/json/json_common.h +++ b/src/core/lib/json/json_common.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_JSON_JSON_COMMON_H -#define GRPC_CORE_JSON_JSON_COMMON_H +#ifndef GRPC_CORE_LIB_JSON_JSON_COMMON_H +#define GRPC_CORE_LIB_JSON_JSON_COMMON_H /* The various json types. */ typedef enum { @@ -46,4 +46,4 @@ typedef enum { GRPC_JSON_TOP_LEVEL } grpc_json_type; -#endif /* GRPC_CORE_JSON_JSON_COMMON_H */ +#endif /* GRPC_CORE_LIB_JSON_JSON_COMMON_H */ diff --git a/src/core/lib/json/json_reader.h b/src/core/lib/json/json_reader.h index f25f44b2ef..a49d6fef68 100644 --- a/src/core/lib/json/json_reader.h +++ b/src/core/lib/json/json_reader.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_JSON_JSON_READER_H -#define GRPC_CORE_JSON_JSON_READER_H +#ifndef GRPC_CORE_LIB_JSON_JSON_READER_H +#define GRPC_CORE_LIB_JSON_JSON_READER_H #include #include "src/core/json/json_common.h" @@ -157,4 +157,4 @@ void grpc_json_reader_init(grpc_json_reader *reader, */ int grpc_json_reader_is_complete(grpc_json_reader *reader); -#endif /* GRPC_CORE_JSON_JSON_READER_H */ +#endif /* GRPC_CORE_LIB_JSON_JSON_READER_H */ diff --git a/src/core/lib/json/json_writer.h b/src/core/lib/json/json_writer.h index c392126950..90b6bc753c 100644 --- a/src/core/lib/json/json_writer.h +++ b/src/core/lib/json/json_writer.h @@ -43,8 +43,8 @@ * a valid UTF-8 string overall. */ -#ifndef GRPC_CORE_JSON_JSON_WRITER_H -#define GRPC_CORE_JSON_JSON_WRITER_H +#ifndef GRPC_CORE_LIB_JSON_JSON_WRITER_H +#define GRPC_CORE_LIB_JSON_JSON_WRITER_H #include @@ -94,4 +94,4 @@ void grpc_json_writer_value_raw_with_len(grpc_json_writer *writer, void grpc_json_writer_value_string(grpc_json_writer *writer, const char *string); -#endif /* GRPC_CORE_JSON_JSON_WRITER_H */ +#endif /* GRPC_CORE_LIB_JSON_JSON_WRITER_H */ diff --git a/src/core/lib/profiling/timers.h b/src/core/lib/profiling/timers.h index 6a188dc566..c8567e8137 100644 --- a/src/core/lib/profiling/timers.h +++ b/src/core/lib/profiling/timers.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_PROFILING_TIMERS_H -#define GRPC_CORE_PROFILING_TIMERS_H +#ifndef GRPC_CORE_LIB_PROFILING_TIMERS_H +#define GRPC_CORE_LIB_PROFILING_TIMERS_H #ifdef __cplusplus extern "C" { @@ -116,4 +116,4 @@ class ProfileScope { #endif #endif -#endif /* GRPC_CORE_PROFILING_TIMERS_H */ +#endif /* GRPC_CORE_LIB_PROFILING_TIMERS_H */ diff --git a/src/core/lib/proto/grpc/lb/v0/load_balancer.pb.h b/src/core/lib/proto/grpc/lb/v0/load_balancer.pb.h index 3599f881bb..671fb9a60b 100644 --- a/src/core/lib/proto/grpc/lb/v0/load_balancer.pb.h +++ b/src/core/lib/proto/grpc/lb/v0/load_balancer.pb.h @@ -33,8 +33,8 @@ /* Automatically generated nanopb header */ /* Generated by nanopb-0.3.5-dev */ -#ifndef PB_LOAD_BALANCER_PB_H_INCLUDED -#define PB_LOAD_BALANCER_PB_H_INCLUDED +#ifndef GRPC_CORE_LIB_PROTO_GRPC_LB_V0_LOAD_BALANCER_PB_H0_LOAD_BALANCER_PB_H +#define GRPC_CORE_LIB_PROTO_GRPC_LB_V0_LOAD_BALANCER_PB_H0_LOAD_BALANCER_PB_H #include "third_party/nanopb/pb.h" #if PB_PROTO_HEADER_VERSION != 30 #error Regenerate this file with the current version of nanopb generator. @@ -179,4 +179,4 @@ extern const pb_field_t grpc_lb_v0_Server_fields[5]; } /* extern "C" */ #endif -#endif +#endif /* GRPC_CORE_LIB_PROTO_GRPC_LB_V0_LOAD_BALANCER_PB_H */ diff --git a/src/core/lib/security/auth_filters.h b/src/core/lib/security/auth_filters.h index 1154a1d914..0fb19e7382 100644 --- a/src/core/lib/security/auth_filters.h +++ b/src/core/lib/security/auth_filters.h @@ -31,12 +31,12 @@ * */ -#ifndef GRPC_CORE_SECURITY_AUTH_FILTERS_H -#define GRPC_CORE_SECURITY_AUTH_FILTERS_H +#ifndef GRPC_CORE_LIB_SECURITY_AUTH_FILTERS_H +#define GRPC_CORE_LIB_SECURITY_AUTH_FILTERS_H #include "src/core/channel/channel_stack.h" extern const grpc_channel_filter grpc_client_auth_filter; extern const grpc_channel_filter grpc_server_auth_filter; -#endif /* GRPC_CORE_SECURITY_AUTH_FILTERS_H */ +#endif /* GRPC_CORE_LIB_SECURITY_AUTH_FILTERS_H */ diff --git a/src/core/lib/security/b64.h b/src/core/lib/security/b64.h index d18f69563d..0bf372a1e7 100644 --- a/src/core/lib/security/b64.h +++ b/src/core/lib/security/b64.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SECURITY_B64_H -#define GRPC_CORE_SECURITY_B64_H +#ifndef GRPC_CORE_LIB_SECURITY_B64_H +#define GRPC_CORE_LIB_SECURITY_B64_H #include @@ -49,4 +49,4 @@ gpr_slice grpc_base64_decode(const char *b64, int url_safe); gpr_slice grpc_base64_decode_with_len(const char *b64, size_t b64_len, int url_safe); -#endif /* GRPC_CORE_SECURITY_B64_H */ +#endif /* GRPC_CORE_LIB_SECURITY_B64_H */ diff --git a/src/core/lib/security/credentials.h b/src/core/lib/security/credentials.h index bfa7cc71bd..c1f451ded1 100644 --- a/src/core/lib/security/credentials.h +++ b/src/core/lib/security/credentials.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SECURITY_CREDENTIALS_H -#define GRPC_CORE_SECURITY_CREDENTIALS_H +#ifndef GRPC_CORE_LIB_SECURITY_CREDENTIALS_H +#define GRPC_CORE_LIB_SECURITY_CREDENTIALS_H #include #include @@ -374,4 +374,4 @@ typedef struct { grpc_credentials_md_store *plugin_md; } grpc_plugin_credentials; -#endif /* GRPC_CORE_SECURITY_CREDENTIALS_H */ +#endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_H */ diff --git a/src/core/lib/security/handshake.h b/src/core/lib/security/handshake.h index 4872045874..2b1f8b9212 100644 --- a/src/core/lib/security/handshake.h +++ b/src/core/lib/security/handshake.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SECURITY_HANDSHAKE_H -#define GRPC_CORE_SECURITY_HANDSHAKE_H +#ifndef GRPC_CORE_LIB_SECURITY_HANDSHAKE_H +#define GRPC_CORE_LIB_SECURITY_HANDSHAKE_H #include "src/core/iomgr/endpoint.h" #include "src/core/security/security_connector.h" @@ -48,4 +48,4 @@ void grpc_do_security_handshake(grpc_exec_ctx *exec_ctx, void grpc_security_handshake_shutdown(grpc_exec_ctx *exec_ctx, void *handshake); -#endif /* GRPC_CORE_SECURITY_HANDSHAKE_H */ +#endif /* GRPC_CORE_LIB_SECURITY_HANDSHAKE_H */ diff --git a/src/core/lib/security/json_token.h b/src/core/lib/security/json_token.h index d183f9b3a3..08ed4bfef3 100644 --- a/src/core/lib/security/json_token.h +++ b/src/core/lib/security/json_token.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SECURITY_JSON_TOKEN_H -#define GRPC_CORE_SECURITY_JSON_TOKEN_H +#ifndef GRPC_CORE_LIB_SECURITY_JSON_TOKEN_H +#define GRPC_CORE_LIB_SECURITY_JSON_TOKEN_H #include #include @@ -115,4 +115,4 @@ grpc_auth_refresh_token grpc_auth_refresh_token_create_from_json( /* Destructs the object. */ void grpc_auth_refresh_token_destruct(grpc_auth_refresh_token *refresh_token); -#endif /* GRPC_CORE_SECURITY_JSON_TOKEN_H */ +#endif /* GRPC_CORE_LIB_SECURITY_JSON_TOKEN_H */ diff --git a/src/core/lib/security/jwt_verifier.h b/src/core/lib/security/jwt_verifier.h index d898d2193f..7db7e6d7b4 100644 --- a/src/core/lib/security/jwt_verifier.h +++ b/src/core/lib/security/jwt_verifier.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SECURITY_JWT_VERIFIER_H -#define GRPC_CORE_SECURITY_JWT_VERIFIER_H +#ifndef GRPC_CORE_LIB_SECURITY_JWT_VERIFIER_H +#define GRPC_CORE_LIB_SECURITY_JWT_VERIFIER_H #include "src/core/iomgr/pollset.h" #include "src/core/json/json.h" @@ -133,4 +133,4 @@ grpc_jwt_claims *grpc_jwt_claims_from_json(grpc_json *json, gpr_slice buffer); grpc_jwt_verifier_status grpc_jwt_claims_check(const grpc_jwt_claims *claims, const char *audience); -#endif /* GRPC_CORE_SECURITY_JWT_VERIFIER_H */ +#endif /* GRPC_CORE_LIB_SECURITY_JWT_VERIFIER_H */ diff --git a/src/core/lib/security/secure_endpoint.h b/src/core/lib/security/secure_endpoint.h index 7368f8424b..f13a4cca44 100644 --- a/src/core/lib/security/secure_endpoint.h +++ b/src/core/lib/security/secure_endpoint.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SECURITY_SECURE_ENDPOINT_H -#define GRPC_CORE_SECURITY_SECURE_ENDPOINT_H +#ifndef GRPC_CORE_LIB_SECURITY_SECURE_ENDPOINT_H +#define GRPC_CORE_LIB_SECURITY_SECURE_ENDPOINT_H #include #include "src/core/iomgr/endpoint.h" @@ -46,4 +46,4 @@ grpc_endpoint *grpc_secure_endpoint_create( struct tsi_frame_protector *protector, grpc_endpoint *to_wrap, gpr_slice *leftover_slices, size_t leftover_nslices); -#endif /* GRPC_CORE_SECURITY_SECURE_ENDPOINT_H */ +#endif /* GRPC_CORE_LIB_SECURITY_SECURE_ENDPOINT_H */ diff --git a/src/core/lib/security/security_connector.h b/src/core/lib/security/security_connector.h index 6f915ebb9d..2818299235 100644 --- a/src/core/lib/security/security_connector.h +++ b/src/core/lib/security/security_connector.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SECURITY_SECURITY_CONNECTOR_H -#define GRPC_CORE_SECURITY_SECURITY_CONNECTOR_H +#ifndef GRPC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_H +#define GRPC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_H #include #include "src/core/iomgr/endpoint.h" @@ -263,4 +263,4 @@ tsi_peer tsi_shallow_peer_from_ssl_auth_context( const grpc_auth_context *auth_context); void tsi_shallow_peer_destruct(tsi_peer *peer); -#endif /* GRPC_CORE_SECURITY_SECURITY_CONNECTOR_H */ +#endif /* GRPC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_H */ diff --git a/src/core/lib/security/security_context.h b/src/core/lib/security/security_context.h index 61601f538b..e205229081 100644 --- a/src/core/lib/security/security_context.h +++ b/src/core/lib/security/security_context.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SECURITY_SECURITY_CONTEXT_H -#define GRPC_CORE_SECURITY_SECURITY_CONTEXT_H +#ifndef GRPC_CORE_LIB_SECURITY_SECURITY_CONTEXT_H +#define GRPC_CORE_LIB_SECURITY_SECURITY_CONTEXT_H #include "src/core/iomgr/pollset.h" #include "src/core/security/credentials.h" @@ -111,4 +111,4 @@ grpc_auth_context *grpc_auth_context_from_arg(const grpc_arg *arg); grpc_auth_context *grpc_find_auth_context_in_args( const grpc_channel_args *args); -#endif /* GRPC_CORE_SECURITY_SECURITY_CONTEXT_H */ +#endif /* GRPC_CORE_LIB_SECURITY_SECURITY_CONTEXT_H */ diff --git a/src/core/lib/statistics/census_interface.h b/src/core/lib/statistics/census_interface.h index ce8ff92cd4..b3b3439072 100644 --- a/src/core/lib/statistics/census_interface.h +++ b/src/core/lib/statistics/census_interface.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_STATISTICS_CENSUS_INTERFACE_H -#define GRPC_CORE_STATISTICS_CENSUS_INTERFACE_H +#ifndef GRPC_CORE_LIB_STATISTICS_CENSUS_INTERFACE_H +#define GRPC_CORE_LIB_STATISTICS_CENSUS_INTERFACE_H #include @@ -73,4 +73,4 @@ census_op_id census_tracing_start_op(void); /* Ends tracing. Calling this function will invalidate the input op_id. */ void census_tracing_end_op(census_op_id op_id); -#endif /* GRPC_CORE_STATISTICS_CENSUS_INTERFACE_H */ +#endif /* GRPC_CORE_LIB_STATISTICS_CENSUS_INTERFACE_H */ diff --git a/src/core/lib/statistics/census_log.h b/src/core/lib/statistics/census_log.h index e7ce0d4433..c3fbd555ba 100644 --- a/src/core/lib/statistics/census_log.h +++ b/src/core/lib/statistics/census_log.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_STATISTICS_CENSUS_LOG_H -#define GRPC_CORE_STATISTICS_CENSUS_LOG_H +#ifndef GRPC_CORE_LIB_STATISTICS_CENSUS_LOG_H +#define GRPC_CORE_LIB_STATISTICS_CENSUS_LOG_H #include @@ -88,4 +88,4 @@ size_t census_log_remaining_space(void); out-of-space. */ int census_log_out_of_space_count(void); -#endif /* GRPC_CORE_STATISTICS_CENSUS_LOG_H */ +#endif /* GRPC_CORE_LIB_STATISTICS_CENSUS_LOG_H */ diff --git a/src/core/lib/statistics/census_rpc_stats.h b/src/core/lib/statistics/census_rpc_stats.h index f7f220e45f..1b45872be8 100644 --- a/src/core/lib/statistics/census_rpc_stats.h +++ b/src/core/lib/statistics/census_rpc_stats.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_STATISTICS_CENSUS_RPC_STATS_H -#define GRPC_CORE_STATISTICS_CENSUS_RPC_STATS_H +#ifndef GRPC_CORE_LIB_STATISTICS_CENSUS_RPC_STATS_H +#define GRPC_CORE_LIB_STATISTICS_CENSUS_RPC_STATS_H #include #include "src/core/statistics/census_interface.h" @@ -98,4 +98,4 @@ void census_stats_store_shutdown(void); } #endif -#endif /* GRPC_CORE_STATISTICS_CENSUS_RPC_STATS_H */ +#endif /* GRPC_CORE_LIB_STATISTICS_CENSUS_RPC_STATS_H */ diff --git a/src/core/lib/statistics/census_tracing.h b/src/core/lib/statistics/census_tracing.h index b611e95bf4..e497bc354d 100644 --- a/src/core/lib/statistics/census_tracing.h +++ b/src/core/lib/statistics/census_tracing.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_STATISTICS_CENSUS_TRACING_H -#define GRPC_CORE_STATISTICS_CENSUS_TRACING_H +#ifndef GRPC_CORE_LIB_STATISTICS_CENSUS_TRACING_H +#define GRPC_CORE_LIB_STATISTICS_CENSUS_TRACING_H #include #include "src/core/statistics/census_rpc_stats.h" @@ -93,4 +93,4 @@ census_trace_obj **census_get_active_ops(int *num_active_ops); } #endif -#endif /* GRPC_CORE_STATISTICS_CENSUS_TRACING_H */ +#endif /* GRPC_CORE_LIB_STATISTICS_CENSUS_TRACING_H */ diff --git a/src/core/lib/statistics/hash_table.h b/src/core/lib/statistics/hash_table.h index f4bf2ba49a..8f74ec82aa 100644 --- a/src/core/lib/statistics/hash_table.h +++ b/src/core/lib/statistics/hash_table.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_STATISTICS_HASH_TABLE_H -#define GRPC_CORE_STATISTICS_HASH_TABLE_H +#ifndef GRPC_CORE_LIB_STATISTICS_HASH_TABLE_H +#define GRPC_CORE_LIB_STATISTICS_HASH_TABLE_H #include @@ -128,4 +128,4 @@ typedef void (*census_ht_itr_cb)(census_ht_key key, const void *val_ptr, should not invalidate data entries. */ uint64_t census_ht_for_all(const census_ht *ht, census_ht_itr_cb); -#endif /* GRPC_CORE_STATISTICS_HASH_TABLE_H */ +#endif /* GRPC_CORE_LIB_STATISTICS_HASH_TABLE_H */ diff --git a/src/core/lib/statistics/window_stats.h b/src/core/lib/statistics/window_stats.h index 774277180f..8dec50d620 100644 --- a/src/core/lib/statistics/window_stats.h +++ b/src/core/lib/statistics/window_stats.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_STATISTICS_WINDOW_STATS_H -#define GRPC_CORE_STATISTICS_WINDOW_STATS_H +#ifndef GRPC_CORE_LIB_STATISTICS_WINDOW_STATS_H +#define GRPC_CORE_LIB_STATISTICS_WINDOW_STATS_H #include @@ -170,4 +170,4 @@ void census_window_stats_get_sums(const struct census_window_stats *wstats, assertion failure). This function is thread-compatible. */ void census_window_stats_destroy(struct census_window_stats *wstats); -#endif /* GRPC_CORE_STATISTICS_WINDOW_STATS_H */ +#endif /* GRPC_CORE_LIB_STATISTICS_WINDOW_STATS_H */ diff --git a/src/core/lib/support/backoff.h b/src/core/lib/support/backoff.h index 0f933c3149..6d40c15546 100644 --- a/src/core/lib/support/backoff.h +++ b/src/core/lib/support/backoff.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SUPPORT_BACKOFF_H -#define GRPC_CORE_SUPPORT_BACKOFF_H +#ifndef GRPC_CORE_LIB_SUPPORT_BACKOFF_H +#define GRPC_CORE_LIB_SUPPORT_BACKOFF_H #include @@ -65,4 +65,4 @@ gpr_timespec gpr_backoff_step(gpr_backoff *backoff, gpr_timespec now); /// instead void gpr_backoff_reset(gpr_backoff *backoff); -#endif /* GRPC_CORE_SUPPORT_BACKOFF_H */ +#endif /* GRPC_CORE_LIB_SUPPORT_BACKOFF_H */ diff --git a/src/core/lib/support/block_annotate.h b/src/core/lib/support/block_annotate.h index 79a18039f4..bd3071655e 100644 --- a/src/core/lib/support/block_annotate.h +++ b/src/core/lib/support/block_annotate.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SUPPORT_BLOCK_ANNOTATE_H -#define GRPC_CORE_SUPPORT_BLOCK_ANNOTATE_H +#ifndef GRPC_CORE_LIB_SUPPORT_BLOCK_ANNOTATE_H +#define GRPC_CORE_LIB_SUPPORT_BLOCK_ANNOTATE_H /* These annotations identify the beginning and end of regions where the code may block for reasons other than synchronization functions. @@ -45,4 +45,4 @@ do { \ } while (0) -#endif /* GRPC_CORE_SUPPORT_BLOCK_ANNOTATE_H */ +#endif /* GRPC_CORE_LIB_SUPPORT_BLOCK_ANNOTATE_H */ diff --git a/src/core/lib/support/env.h b/src/core/lib/support/env.h index 2902456947..ddc4ee3c6d 100644 --- a/src/core/lib/support/env.h +++ b/src/core/lib/support/env.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SUPPORT_ENV_H -#define GRPC_CORE_SUPPORT_ENV_H +#ifndef GRPC_CORE_LIB_SUPPORT_ENV_H +#define GRPC_CORE_LIB_SUPPORT_ENV_H #include @@ -57,4 +57,4 @@ void gpr_setenv(const char *name, const char *value); } #endif -#endif /* GRPC_CORE_SUPPORT_ENV_H */ +#endif /* GRPC_CORE_LIB_SUPPORT_ENV_H */ diff --git a/src/core/lib/support/load_file.h b/src/core/lib/support/load_file.h index 5896654e9a..fe030c967e 100644 --- a/src/core/lib/support/load_file.h +++ b/src/core/lib/support/load_file.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SUPPORT_LOAD_FILE_H -#define GRPC_CORE_SUPPORT_LOAD_FILE_H +#ifndef GRPC_CORE_LIB_SUPPORT_LOAD_FILE_H +#define GRPC_CORE_LIB_SUPPORT_LOAD_FILE_H #include @@ -52,4 +52,4 @@ gpr_slice gpr_load_file(const char *filename, int add_null_terminator, } #endif -#endif /* GRPC_CORE_SUPPORT_LOAD_FILE_H */ +#endif /* GRPC_CORE_LIB_SUPPORT_LOAD_FILE_H */ diff --git a/src/core/lib/support/murmur_hash.h b/src/core/lib/support/murmur_hash.h index 0f0b399e5d..e54cdf2592 100644 --- a/src/core/lib/support/murmur_hash.h +++ b/src/core/lib/support/murmur_hash.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SUPPORT_MURMUR_HASH_H -#define GRPC_CORE_SUPPORT_MURMUR_HASH_H +#ifndef GRPC_CORE_LIB_SUPPORT_MURMUR_HASH_H +#define GRPC_CORE_LIB_SUPPORT_MURMUR_HASH_H #include @@ -41,4 +41,4 @@ /* compute the hash of key (length len) */ uint32_t gpr_murmur_hash3(const void *key, size_t len, uint32_t seed); -#endif /* GRPC_CORE_SUPPORT_MURMUR_HASH_H */ +#endif /* GRPC_CORE_LIB_SUPPORT_MURMUR_HASH_H */ diff --git a/src/core/lib/support/stack_lockfree.h b/src/core/lib/support/stack_lockfree.h index d6fd06d67c..a030a01d1f 100644 --- a/src/core/lib/support/stack_lockfree.h +++ b/src/core/lib/support/stack_lockfree.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SUPPORT_STACK_LOCKFREE_H -#define GRPC_CORE_SUPPORT_STACK_LOCKFREE_H +#ifndef GRPC_CORE_LIB_SUPPORT_STACK_LOCKFREE_H +#define GRPC_CORE_LIB_SUPPORT_STACK_LOCKFREE_H #include @@ -50,4 +50,4 @@ int gpr_stack_lockfree_push(gpr_stack_lockfree *, int entry); /* Returns -1 on empty or the actual entry number */ int gpr_stack_lockfree_pop(gpr_stack_lockfree *stack); -#endif /* GRPC_CORE_SUPPORT_STACK_LOCKFREE_H */ +#endif /* GRPC_CORE_LIB_SUPPORT_STACK_LOCKFREE_H */ diff --git a/src/core/lib/support/string.h b/src/core/lib/support/string.h index 8ff16882ab..68c02878e0 100644 --- a/src/core/lib/support/string.h +++ b/src/core/lib/support/string.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SUPPORT_STRING_H -#define GRPC_CORE_SUPPORT_STRING_H +#ifndef GRPC_CORE_LIB_SUPPORT_STRING_H +#define GRPC_CORE_LIB_SUPPORT_STRING_H #include @@ -118,4 +118,4 @@ char *gpr_strvec_flatten(gpr_strvec *strs, size_t *total_length); } #endif -#endif /* GRPC_CORE_SUPPORT_STRING_H */ +#endif /* GRPC_CORE_LIB_SUPPORT_STRING_H */ diff --git a/src/core/lib/support/string_win32.h b/src/core/lib/support/string_win32.h index c9ae8d9932..f47d567715 100644 --- a/src/core/lib/support/string_win32.h +++ b/src/core/lib/support/string_win32.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SUPPORT_STRING_WIN32_H -#define GRPC_CORE_SUPPORT_STRING_WIN32_H +#ifndef GRPC_CORE_LIB_SUPPORT_STRING_WIN32_H +#define GRPC_CORE_LIB_SUPPORT_STRING_WIN32_H #include @@ -44,4 +44,4 @@ LPSTR gpr_tchar_to_char(LPCTSTR input); #endif /* GPR_WIN32 */ -#endif /* GRPC_CORE_SUPPORT_STRING_WIN32_H */ +#endif /* GRPC_CORE_LIB_SUPPORT_STRING_WIN32_H */ diff --git a/src/core/lib/support/thd_internal.h b/src/core/lib/support/thd_internal.h index 33b904e59b..f269a3249e 100644 --- a/src/core/lib/support/thd_internal.h +++ b/src/core/lib/support/thd_internal.h @@ -31,9 +31,9 @@ * */ -#ifndef GRPC_CORE_SUPPORT_THD_INTERNAL_H -#define GRPC_CORE_SUPPORT_THD_INTERNAL_H +#ifndef GRPC_CORE_LIB_SUPPORT_THD_INTERNAL_H +#define GRPC_CORE_LIB_SUPPORT_THD_INTERNAL_H /* Internal interfaces between modules within the gpr support library. */ -#endif /* GRPC_CORE_SUPPORT_THD_INTERNAL_H */ +#endif /* GRPC_CORE_LIB_SUPPORT_THD_INTERNAL_H */ diff --git a/src/core/lib/support/time_precise.h b/src/core/lib/support/time_precise.h index 871c99a623..e1faee1f9f 100644 --- a/src/core/lib/support/time_precise.h +++ b/src/core/lib/support/time_precise.h @@ -31,12 +31,12 @@ * */ -#ifndef GRPC_CORE_SUPPORT_TIME_PRECISE_H -#define GRPC_CORE_SUPPORT_TIME_PRECISE_H +#ifndef GRPC_CORE_LIB_SUPPORT_TIME_PRECISE_H +#define GRPC_CORE_LIB_SUPPORT_TIME_PRECISE_H #include void gpr_precise_clock_init(void); void gpr_precise_clock_now(gpr_timespec *clk); -#endif /* GRPC_CORE_SUPPORT_TIME_PRECISE_H */ +#endif /* GRPC_CORE_LIB_SUPPORT_TIME_PRECISE_H */ diff --git a/src/core/lib/support/tmpfile.h b/src/core/lib/support/tmpfile.h index df6f8692bb..4fec2076e3 100644 --- a/src/core/lib/support/tmpfile.h +++ b/src/core/lib/support/tmpfile.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SUPPORT_TMPFILE_H -#define GRPC_CORE_SUPPORT_TMPFILE_H +#ifndef GRPC_CORE_LIB_SUPPORT_TMPFILE_H +#define GRPC_CORE_LIB_SUPPORT_TMPFILE_H #include @@ -52,4 +52,4 @@ FILE *gpr_tmpfile(const char *prefix, char **tmp_filename); } #endif -#endif /* GRPC_CORE_SUPPORT_TMPFILE_H */ +#endif /* GRPC_CORE_LIB_SUPPORT_TMPFILE_H */ diff --git a/src/core/lib/surface/api_trace.h b/src/core/lib/surface/api_trace.h index af53829de4..00d71677e5 100644 --- a/src/core/lib/surface/api_trace.h +++ b/src/core/lib/surface/api_trace.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SURFACE_API_TRACE_H -#define GRPC_CORE_SURFACE_API_TRACE_H +#ifndef GRPC_CORE_LIB_SURFACE_API_TRACE_H +#define GRPC_CORE_LIB_SURFACE_API_TRACE_H #include #include "src/core/debug/trace.h" @@ -62,4 +62,4 @@ extern int grpc_api_trace; gpr_log(GPR_INFO, fmt GRPC_API_TRACE_UNWRAP##nargs args); \ } -#endif /* GRPC_CORE_SURFACE_API_TRACE_H */ +#endif /* GRPC_CORE_LIB_SURFACE_API_TRACE_H */ diff --git a/src/core/lib/surface/call.h b/src/core/lib/surface/call.h index d2edf03d45..09e19dc779 100644 --- a/src/core/lib/surface/call.h +++ b/src/core/lib/surface/call.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SURFACE_CALL_H -#define GRPC_CORE_SURFACE_CALL_H +#ifndef GRPC_CORE_LIB_SURFACE_CALL_H +#define GRPC_CORE_LIB_SURFACE_CALL_H #include "src/core/channel/channel_stack.h" #include "src/core/channel/context.h" @@ -113,4 +113,4 @@ grpc_compression_algorithm grpc_call_compression_for_level( } #endif -#endif /* GRPC_CORE_SURFACE_CALL_H */ +#endif /* GRPC_CORE_LIB_SURFACE_CALL_H */ diff --git a/src/core/lib/surface/call_test_only.h b/src/core/lib/surface/call_test_only.h index fdc43a383b..400214189e 100644 --- a/src/core/lib/surface/call_test_only.h +++ b/src/core/lib/surface/call_test_only.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SURFACE_CALL_TEST_ONLY_H -#define GRPC_CORE_SURFACE_CALL_TEST_ONLY_H +#ifndef GRPC_CORE_LIB_SURFACE_CALL_TEST_ONLY_H +#define GRPC_CORE_LIB_SURFACE_CALL_TEST_ONLY_H #include @@ -61,4 +61,4 @@ uint32_t grpc_call_test_only_get_encodings_accepted_by_peer(grpc_call *call); } #endif -#endif /* GRPC_CORE_SURFACE_CALL_TEST_ONLY_H */ +#endif /* GRPC_CORE_LIB_SURFACE_CALL_TEST_ONLY_H */ diff --git a/src/core/lib/surface/channel.h b/src/core/lib/surface/channel.h index 6a803ffe23..d0e15bbeb8 100644 --- a/src/core/lib/surface/channel.h +++ b/src/core/lib/surface/channel.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SURFACE_CHANNEL_H -#define GRPC_CORE_SURFACE_CHANNEL_H +#ifndef GRPC_CORE_LIB_SURFACE_CHANNEL_H +#define GRPC_CORE_LIB_SURFACE_CHANNEL_H #include "src/core/channel/channel_stack.h" #include "src/core/client_config/subchannel_factory.h" @@ -72,4 +72,4 @@ void grpc_channel_internal_unref(grpc_exec_ctx *exec_ctx, grpc_channel_internal_unref(exec_ctx, channel) #endif -#endif /* GRPC_CORE_SURFACE_CHANNEL_H */ +#endif /* GRPC_CORE_LIB_SURFACE_CHANNEL_H */ diff --git a/src/core/lib/surface/channel_init.h b/src/core/lib/surface/channel_init.h index 06faef6ddb..ef994b940f 100644 --- a/src/core/lib/surface/channel_init.h +++ b/src/core/lib/surface/channel_init.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SURFACE_CHANNEL_INIT_H -#define GRPC_CORE_SURFACE_CHANNEL_INIT_H +#ifndef GRPC_CORE_LIB_SURFACE_CHANNEL_INIT_H +#define GRPC_CORE_LIB_SURFACE_CHANNEL_INIT_H #include "src/core/channel/channel_stack_builder.h" #include "src/core/surface/channel_stack_type.h" @@ -83,4 +83,4 @@ void *grpc_channel_init_create_stack( const grpc_channel_args *args, int initial_refs, grpc_iomgr_cb_func destroy, void *destroy_arg, grpc_transport *optional_transport); -#endif /* GRPC_CORE_SURFACE_CHANNEL_INIT_H */ +#endif /* GRPC_CORE_LIB_SURFACE_CHANNEL_INIT_H */ diff --git a/src/core/lib/surface/channel_stack_type.h b/src/core/lib/surface/channel_stack_type.h index 75a1b9c072..16608fa386 100644 --- a/src/core/lib/surface/channel_stack_type.h +++ b/src/core/lib/surface/channel_stack_type.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SURFACE_CHANNEL_STACK_TYPE_H -#define GRPC_CORE_SURFACE_CHANNEL_STACK_TYPE_H +#ifndef GRPC_CORE_LIB_SURFACE_CHANNEL_STACK_TYPE_H +#define GRPC_CORE_LIB_SURFACE_CHANNEL_STACK_TYPE_H #include @@ -55,4 +55,4 @@ typedef enum { bool grpc_channel_stack_type_is_client(grpc_channel_stack_type type); -#endif /* GRPC_CORE_SURFACE_CHANNEL_STACK_TYPE_H */ +#endif /* GRPC_CORE_LIB_SURFACE_CHANNEL_STACK_TYPE_H */ diff --git a/src/core/lib/surface/completion_queue.h b/src/core/lib/surface/completion_queue.h index 213d89c079..08c07f3baa 100644 --- a/src/core/lib/surface/completion_queue.h +++ b/src/core/lib/surface/completion_queue.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SURFACE_COMPLETION_QUEUE_H -#define GRPC_CORE_SURFACE_COMPLETION_QUEUE_H +#ifndef GRPC_CORE_LIB_SURFACE_COMPLETION_QUEUE_H +#define GRPC_CORE_LIB_SURFACE_COMPLETION_QUEUE_H /* Internal API for completion queues */ @@ -88,4 +88,4 @@ int grpc_cq_is_server_cq(grpc_completion_queue *cc); void grpc_cq_global_init(void); void grpc_cq_global_shutdown(void); -#endif /* GRPC_CORE_SURFACE_COMPLETION_QUEUE_H */ +#endif /* GRPC_CORE_LIB_SURFACE_COMPLETION_QUEUE_H */ diff --git a/src/core/lib/surface/event_string.h b/src/core/lib/surface/event_string.h index d0598cecca..577e9c718f 100644 --- a/src/core/lib/surface/event_string.h +++ b/src/core/lib/surface/event_string.h @@ -31,12 +31,12 @@ * */ -#ifndef GRPC_CORE_SURFACE_EVENT_STRING_H -#define GRPC_CORE_SURFACE_EVENT_STRING_H +#ifndef GRPC_CORE_LIB_SURFACE_EVENT_STRING_H +#define GRPC_CORE_LIB_SURFACE_EVENT_STRING_H #include /* Returns a string describing an event. Must be later freed with gpr_free() */ char *grpc_event_string(grpc_event *ev); -#endif /* GRPC_CORE_SURFACE_EVENT_STRING_H */ +#endif /* GRPC_CORE_LIB_SURFACE_EVENT_STRING_H */ diff --git a/src/core/lib/surface/init.h b/src/core/lib/surface/init.h index 5e358c7022..10e2a5896e 100644 --- a/src/core/lib/surface/init.h +++ b/src/core/lib/surface/init.h @@ -31,11 +31,11 @@ * */ -#ifndef GRPC_CORE_SURFACE_INIT_H -#define GRPC_CORE_SURFACE_INIT_H +#ifndef GRPC_CORE_LIB_SURFACE_INIT_H +#define GRPC_CORE_LIB_SURFACE_INIT_H void grpc_register_security_filters(void); void grpc_security_pre_init(void); int grpc_is_initialized(void); -#endif /* GRPC_CORE_SURFACE_INIT_H */ +#endif /* GRPC_CORE_LIB_SURFACE_INIT_H */ diff --git a/src/core/lib/surface/lame_client.h b/src/core/lib/surface/lame_client.h index 3f3abd2ffe..cee9500f3e 100644 --- a/src/core/lib/surface/lame_client.h +++ b/src/core/lib/surface/lame_client.h @@ -31,11 +31,11 @@ * */ -#ifndef GRPC_CORE_SURFACE_LAME_CLIENT_H -#define GRPC_CORE_SURFACE_LAME_CLIENT_H +#ifndef GRPC_CORE_LIB_SURFACE_LAME_CLIENT_H +#define GRPC_CORE_LIB_SURFACE_LAME_CLIENT_H #include "src/core/channel/channel_stack.h" extern const grpc_channel_filter grpc_lame_filter; -#endif /* GRPC_CORE_SURFACE_LAME_CLIENT_H */ +#endif /* GRPC_CORE_LIB_SURFACE_LAME_CLIENT_H */ diff --git a/src/core/lib/surface/server.h b/src/core/lib/surface/server.h index cd62eadd7f..969d268053 100644 --- a/src/core/lib/surface/server.h +++ b/src/core/lib/surface/server.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SURFACE_SERVER_H -#define GRPC_CORE_SURFACE_SERVER_H +#ifndef GRPC_CORE_LIB_SURFACE_SERVER_H +#define GRPC_CORE_LIB_SURFACE_SERVER_H #include #include "src/core/channel/channel_stack.h" @@ -59,4 +59,4 @@ const grpc_channel_args *grpc_server_get_channel_args(grpc_server *server); int grpc_server_has_open_connections(grpc_server *server); -#endif /* GRPC_CORE_SURFACE_SERVER_H */ +#endif /* GRPC_CORE_LIB_SURFACE_SERVER_H */ diff --git a/src/core/lib/surface/surface_trace.h b/src/core/lib/surface/surface_trace.h index a55a88e44d..1046eb0c83 100644 --- a/src/core/lib/surface/surface_trace.h +++ b/src/core/lib/surface/surface_trace.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_SURFACE_SURFACE_TRACE_H -#define GRPC_CORE_SURFACE_SURFACE_TRACE_H +#ifndef GRPC_CORE_LIB_SURFACE_SURFACE_TRACE_H +#define GRPC_CORE_LIB_SURFACE_SURFACE_TRACE_H #include #include "src/core/debug/trace.h" @@ -45,4 +45,4 @@ gpr_free(_ev); \ } -#endif /* GRPC_CORE_SURFACE_SURFACE_TRACE_H */ +#endif /* GRPC_CORE_LIB_SURFACE_SURFACE_TRACE_H */ diff --git a/src/core/lib/transport/byte_stream.h b/src/core/lib/transport/byte_stream.h index ab42d07e7e..ae01f91295 100644 --- a/src/core/lib/transport/byte_stream.h +++ b/src/core/lib/transport/byte_stream.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_BYTE_STREAM_H -#define GRPC_CORE_TRANSPORT_BYTE_STREAM_H +#ifndef GRPC_CORE_LIB_TRANSPORT_BYTE_STREAM_H +#define GRPC_CORE_LIB_TRANSPORT_BYTE_STREAM_H #include #include "src/core/iomgr/exec_ctx.h" @@ -86,4 +86,4 @@ void grpc_slice_buffer_stream_init(grpc_slice_buffer_stream *stream, gpr_slice_buffer *slice_buffer, uint32_t flags); -#endif /* GRPC_CORE_TRANSPORT_BYTE_STREAM_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_BYTE_STREAM_H */ diff --git a/src/core/lib/transport/chttp2/alpn.h b/src/core/lib/transport/chttp2/alpn.h index 68010e3155..a9184e63a4 100644 --- a/src/core/lib/transport/chttp2/alpn.h +++ b/src/core/lib/transport/chttp2/alpn.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_ALPN_H -#define GRPC_CORE_TRANSPORT_CHTTP2_ALPN_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_ALPN_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_ALPN_H #include @@ -46,4 +46,4 @@ size_t grpc_chttp2_num_alpn_versions(void); * grpc_chttp2_num_alpn_versions()) */ const char *grpc_chttp2_get_alpn_version_index(size_t i); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_ALPN_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_ALPN_H */ diff --git a/src/core/lib/transport/chttp2/bin_encoder.h b/src/core/lib/transport/chttp2/bin_encoder.h index edb6f2dad1..1c5cd1e1c6 100644 --- a/src/core/lib/transport/chttp2/bin_encoder.h +++ b/src/core/lib/transport/chttp2/bin_encoder.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_BIN_ENCODER_H -#define GRPC_CORE_TRANSPORT_CHTTP2_BIN_ENCODER_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_BIN_ENCODER_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_BIN_ENCODER_H #include @@ -51,4 +51,4 @@ gpr_slice grpc_chttp2_huffman_compress(gpr_slice input); return y; */ gpr_slice grpc_chttp2_base64_encode_and_huffman_compress(gpr_slice input); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_BIN_ENCODER_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_BIN_ENCODER_H */ diff --git a/src/core/lib/transport/chttp2/frame.h b/src/core/lib/transport/chttp2/frame.h index 560a6675af..4674bc9703 100644 --- a/src/core/lib/transport/chttp2/frame.h +++ b/src/core/lib/transport/chttp2/frame.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_FRAME_H -#define GRPC_CORE_TRANSPORT_CHTTP2_FRAME_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_H #include #include @@ -66,4 +66,4 @@ typedef struct grpc_chttp2_transport_parsing grpc_chttp2_transport_parsing; #define GRPC_CHTTP2_DATA_FLAG_PADDED 8 #define GRPC_CHTTP2_FLAG_HAS_PRIORITY 0x20 -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_FRAME_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_H */ diff --git a/src/core/lib/transport/chttp2/frame_data.h b/src/core/lib/transport/chttp2/frame_data.h index 9dbaa60d44..725863bbb7 100644 --- a/src/core/lib/transport/chttp2/frame_data.h +++ b/src/core/lib/transport/chttp2/frame_data.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_FRAME_DATA_H -#define GRPC_CORE_TRANSPORT_CHTTP2_FRAME_DATA_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_DATA_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_DATA_H /* Parser for GRPC streams embedded in DATA frames */ @@ -98,4 +98,4 @@ void grpc_chttp2_encode_data(uint32_t id, gpr_slice_buffer *inbuf, uint32_t write_bytes, int is_eof, gpr_slice_buffer *outbuf); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_FRAME_DATA_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_DATA_H */ diff --git a/src/core/lib/transport/chttp2/frame_goaway.h b/src/core/lib/transport/chttp2/frame_goaway.h index b980e47723..1ed2b62ec6 100644 --- a/src/core/lib/transport/chttp2/frame_goaway.h +++ b/src/core/lib/transport/chttp2/frame_goaway.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_FRAME_GOAWAY_H -#define GRPC_CORE_TRANSPORT_CHTTP2_FRAME_GOAWAY_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_GOAWAY_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_GOAWAY_H #include #include @@ -74,4 +74,4 @@ void grpc_chttp2_goaway_append(uint32_t last_stream_id, uint32_t error_code, gpr_slice debug_data, gpr_slice_buffer *slice_buffer); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_FRAME_GOAWAY_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_GOAWAY_H */ diff --git a/src/core/lib/transport/chttp2/frame_ping.h b/src/core/lib/transport/chttp2/frame_ping.h index 2412cd7a6f..87bf1d3257 100644 --- a/src/core/lib/transport/chttp2/frame_ping.h +++ b/src/core/lib/transport/chttp2/frame_ping.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_FRAME_PING_H -#define GRPC_CORE_TRANSPORT_CHTTP2_FRAME_PING_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_PING_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_PING_H #include #include "src/core/iomgr/exec_ctx.h" @@ -53,4 +53,4 @@ grpc_chttp2_parse_error grpc_chttp2_ping_parser_parse( grpc_chttp2_transport_parsing *transport_parsing, grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_FRAME_PING_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_PING_H */ diff --git a/src/core/lib/transport/chttp2/frame_rst_stream.h b/src/core/lib/transport/chttp2/frame_rst_stream.h index f725c5d767..2dd009d3c2 100644 --- a/src/core/lib/transport/chttp2/frame_rst_stream.h +++ b/src/core/lib/transport/chttp2/frame_rst_stream.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_FRAME_RST_STREAM_H -#define GRPC_CORE_TRANSPORT_CHTTP2_FRAME_RST_STREAM_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_RST_STREAM_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_RST_STREAM_H #include #include "src/core/iomgr/exec_ctx.h" @@ -52,4 +52,4 @@ grpc_chttp2_parse_error grpc_chttp2_rst_stream_parser_parse( grpc_chttp2_transport_parsing *transport_parsing, grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_FRAME_RST_STREAM_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_RST_STREAM_H */ diff --git a/src/core/lib/transport/chttp2/frame_settings.h b/src/core/lib/transport/chttp2/frame_settings.h index 59dbff9b40..fa1db96638 100644 --- a/src/core/lib/transport/chttp2/frame_settings.h +++ b/src/core/lib/transport/chttp2/frame_settings.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_FRAME_SETTINGS_H -#define GRPC_CORE_TRANSPORT_CHTTP2_FRAME_SETTINGS_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_SETTINGS_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_SETTINGS_H #include #include @@ -100,4 +100,4 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse( grpc_chttp2_transport_parsing *transport_parsing, grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_FRAME_SETTINGS_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_SETTINGS_H */ diff --git a/src/core/lib/transport/chttp2/frame_window_update.h b/src/core/lib/transport/chttp2/frame_window_update.h index 9b7ca3ce63..88e458bbfb 100644 --- a/src/core/lib/transport/chttp2/frame_window_update.h +++ b/src/core/lib/transport/chttp2/frame_window_update.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_FRAME_WINDOW_UPDATE_H -#define GRPC_CORE_TRANSPORT_CHTTP2_FRAME_WINDOW_UPDATE_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_WINDOW_UPDATE_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_WINDOW_UPDATE_H #include #include "src/core/iomgr/exec_ctx.h" @@ -53,4 +53,4 @@ grpc_chttp2_parse_error grpc_chttp2_window_update_parser_parse( grpc_chttp2_transport_parsing *transport_parsing, grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_FRAME_WINDOW_UPDATE_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_WINDOW_UPDATE_H */ diff --git a/src/core/lib/transport/chttp2/hpack_encoder.h b/src/core/lib/transport/chttp2/hpack_encoder.h index 6d86eb7c83..e842f5719e 100644 --- a/src/core/lib/transport/chttp2/hpack_encoder.h +++ b/src/core/lib/transport/chttp2/hpack_encoder.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_HPACK_ENCODER_H -#define GRPC_CORE_TRANSPORT_CHTTP2_HPACK_ENCODER_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_HPACK_ENCODER_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_HPACK_ENCODER_H #include #include @@ -92,4 +92,4 @@ void grpc_chttp2_encode_header(grpc_chttp2_hpack_compressor *c, uint32_t id, grpc_metadata_batch *metadata, int is_eof, gpr_slice_buffer *outbuf); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_HPACK_ENCODER_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_HPACK_ENCODER_H */ diff --git a/src/core/lib/transport/chttp2/hpack_parser.h b/src/core/lib/transport/chttp2/hpack_parser.h index 6a6d136da2..2a47cdf93c 100644 --- a/src/core/lib/transport/chttp2/hpack_parser.h +++ b/src/core/lib/transport/chttp2/hpack_parser.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_HPACK_PARSER_H -#define GRPC_CORE_TRANSPORT_CHTTP2_HPACK_PARSER_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_HPACK_PARSER_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_HPACK_PARSER_H #include @@ -113,4 +113,4 @@ grpc_chttp2_parse_error grpc_chttp2_header_parser_parse( grpc_chttp2_transport_parsing *transport_parsing, grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_HPACK_PARSER_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_HPACK_PARSER_H */ diff --git a/src/core/lib/transport/chttp2/hpack_table.h b/src/core/lib/transport/chttp2/hpack_table.h index c984ca35e4..eddb99ee1c 100644 --- a/src/core/lib/transport/chttp2/hpack_table.h +++ b/src/core/lib/transport/chttp2/hpack_table.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_HPACK_TABLE_H -#define GRPC_CORE_TRANSPORT_CHTTP2_HPACK_TABLE_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_HPACK_TABLE_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_HPACK_TABLE_H #include #include @@ -105,4 +105,4 @@ typedef struct { grpc_chttp2_hptbl_find_result grpc_chttp2_hptbl_find( const grpc_chttp2_hptbl *tbl, grpc_mdelem *md); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_HPACK_TABLE_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_HPACK_TABLE_H */ diff --git a/src/core/lib/transport/chttp2/http2_errors.h b/src/core/lib/transport/chttp2/http2_errors.h index 4290df3d89..0238f9d80b 100644 --- a/src/core/lib/transport/chttp2/http2_errors.h +++ b/src/core/lib/transport/chttp2/http2_errors.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_HTTP2_ERRORS_H -#define GRPC_CORE_TRANSPORT_CHTTP2_HTTP2_ERRORS_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_HTTP2_ERRORS_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_HTTP2_ERRORS_H /* error codes for RST_STREAM from http2 draft 14 section 7 */ typedef enum { @@ -53,4 +53,4 @@ typedef enum { GRPC_CHTTP2__ERROR_DO_NOT_USE = -1 } grpc_chttp2_error_code; -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_HTTP2_ERRORS_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_HTTP2_ERRORS_H */ diff --git a/src/core/lib/transport/chttp2/huffsyms.h b/src/core/lib/transport/chttp2/huffsyms.h index 9c4f09dcf6..1ca77b9207 100644 --- a/src/core/lib/transport/chttp2/huffsyms.h +++ b/src/core/lib/transport/chttp2/huffsyms.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_HUFFSYMS_H -#define GRPC_CORE_TRANSPORT_CHTTP2_HUFFSYMS_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_HUFFSYMS_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_HUFFSYMS_H /* HPACK static huffman table */ @@ -45,4 +45,4 @@ typedef struct { extern const grpc_chttp2_huffsym grpc_chttp2_huffsyms[GRPC_CHTTP2_NUM_HUFFSYMS]; -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_HUFFSYMS_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_HUFFSYMS_H */ diff --git a/src/core/lib/transport/chttp2/incoming_metadata.h b/src/core/lib/transport/chttp2/incoming_metadata.h index 52454f348c..87f360e1f2 100644 --- a/src/core/lib/transport/chttp2/incoming_metadata.h +++ b/src/core/lib/transport/chttp2/incoming_metadata.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_INCOMING_METADATA_H -#define GRPC_CORE_TRANSPORT_CHTTP2_INCOMING_METADATA_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_INCOMING_METADATA_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_INCOMING_METADATA_H #include "src/core/transport/transport.h" @@ -57,4 +57,4 @@ void grpc_chttp2_incoming_metadata_buffer_add( void grpc_chttp2_incoming_metadata_buffer_set_deadline( grpc_chttp2_incoming_metadata_buffer *buffer, gpr_timespec deadline); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_INCOMING_METADATA_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_INCOMING_METADATA_H */ diff --git a/src/core/lib/transport/chttp2/internal.h b/src/core/lib/transport/chttp2/internal.h index 0690cb37cd..2e7b334426 100644 --- a/src/core/lib/transport/chttp2/internal.h +++ b/src/core/lib/transport/chttp2/internal.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_INTERNAL_H -#define GRPC_CORE_TRANSPORT_CHTTP2_INTERNAL_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_INTERNAL_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_INTERNAL_H #include #include @@ -777,4 +777,4 @@ void grpc_chttp2_ack_ping(grpc_exec_ctx *exec_ctx, void grpc_chttp2_become_writable(grpc_chttp2_transport_global *transport_global, grpc_chttp2_stream_global *stream_global); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_INTERNAL_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_INTERNAL_H */ diff --git a/src/core/lib/transport/chttp2/status_conversion.h b/src/core/lib/transport/chttp2/status_conversion.h index c6e066bb5d..12720c05f9 100644 --- a/src/core/lib/transport/chttp2/status_conversion.h +++ b/src/core/lib/transport/chttp2/status_conversion.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_STATUS_CONVERSION_H -#define GRPC_CORE_TRANSPORT_CHTTP2_STATUS_CONVERSION_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_STATUS_CONVERSION_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_STATUS_CONVERSION_H #include #include "src/core/transport/chttp2/http2_errors.h" @@ -47,4 +47,4 @@ grpc_status_code grpc_chttp2_http2_error_to_grpc_status( grpc_status_code grpc_chttp2_http2_status_to_grpc_status(int status); int grpc_chttp2_grpc_status_to_http2_status(grpc_status_code status); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_STATUS_CONVERSION_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_STATUS_CONVERSION_H */ diff --git a/src/core/lib/transport/chttp2/stream_map.h b/src/core/lib/transport/chttp2/stream_map.h index 957a58a4f2..1c56b18e54 100644 --- a/src/core/lib/transport/chttp2/stream_map.h +++ b/src/core/lib/transport/chttp2/stream_map.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_STREAM_MAP_H -#define GRPC_CORE_TRANSPORT_CHTTP2_STREAM_MAP_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_STREAM_MAP_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_STREAM_MAP_H #include @@ -81,4 +81,4 @@ void grpc_chttp2_stream_map_for_each(grpc_chttp2_stream_map *map, void *value), void *user_data); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_STREAM_MAP_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_STREAM_MAP_H */ diff --git a/src/core/lib/transport/chttp2/timeout_encoding.h b/src/core/lib/transport/chttp2/timeout_encoding.h index f8e25226eb..9bb3c36d72 100644 --- a/src/core/lib/transport/chttp2/timeout_encoding.h +++ b/src/core/lib/transport/chttp2/timeout_encoding.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_TIMEOUT_ENCODING_H -#define GRPC_CORE_TRANSPORT_CHTTP2_TIMEOUT_ENCODING_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_TIMEOUT_ENCODING_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_TIMEOUT_ENCODING_H #include #include "src/core/support/string.h" @@ -44,4 +44,4 @@ void grpc_chttp2_encode_timeout(gpr_timespec timeout, char *buffer); int grpc_chttp2_decode_timeout(const char *buffer, gpr_timespec *timeout); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_TIMEOUT_ENCODING_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_TIMEOUT_ENCODING_H */ diff --git a/src/core/lib/transport/chttp2/varint.h b/src/core/lib/transport/chttp2/varint.h index 7ab9d22ab5..e4a0ae3c22 100644 --- a/src/core/lib/transport/chttp2/varint.h +++ b/src/core/lib/transport/chttp2/varint.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_VARINT_H -#define GRPC_CORE_TRANSPORT_CHTTP2_VARINT_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_VARINT_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_VARINT_H #include @@ -72,4 +72,4 @@ void grpc_chttp2_hpack_write_varint_tail(uint32_t tail_value, uint8_t* target, } \ } while (0) -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_VARINT_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_VARINT_H */ diff --git a/src/core/lib/transport/chttp2_transport.h b/src/core/lib/transport/chttp2_transport.h index 9a6cf0ed35..b188219982 100644 --- a/src/core/lib/transport/chttp2_transport.h +++ b/src/core/lib/transport/chttp2_transport.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CHTTP2_TRANSPORT_H -#define GRPC_CORE_TRANSPORT_CHTTP2_TRANSPORT_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_TRANSPORT_H +#define GRPC_CORE_LIB_TRANSPORT_CHTTP2_TRANSPORT_H #include "src/core/iomgr/endpoint.h" #include "src/core/transport/transport.h" @@ -48,4 +48,4 @@ void grpc_chttp2_transport_start_reading(grpc_exec_ctx *exec_ctx, grpc_transport *transport, gpr_slice *slices, size_t nslices); -#endif /* GRPC_CORE_TRANSPORT_CHTTP2_TRANSPORT_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CHTTP2_TRANSPORT_H */ diff --git a/src/core/lib/transport/connectivity_state.h b/src/core/lib/transport/connectivity_state.h index b4a3ce924d..dc6623c46c 100644 --- a/src/core/lib/transport/connectivity_state.h +++ b/src/core/lib/transport/connectivity_state.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_CONNECTIVITY_STATE_H -#define GRPC_CORE_TRANSPORT_CONNECTIVITY_STATE_H +#ifndef GRPC_CORE_LIB_TRANSPORT_CONNECTIVITY_STATE_H +#define GRPC_CORE_LIB_TRANSPORT_CONNECTIVITY_STATE_H #include #include "src/core/iomgr/exec_ctx.h" @@ -82,4 +82,4 @@ int grpc_connectivity_state_notify_on_state_change( grpc_exec_ctx *exec_ctx, grpc_connectivity_state_tracker *tracker, grpc_connectivity_state *current, grpc_closure *notify); -#endif /* GRPC_CORE_TRANSPORT_CONNECTIVITY_STATE_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_CONNECTIVITY_STATE_H */ diff --git a/src/core/lib/transport/metadata.h b/src/core/lib/transport/metadata.h index 5ab397848c..d72ec9accc 100644 --- a/src/core/lib/transport/metadata.h +++ b/src/core/lib/transport/metadata.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_METADATA_H -#define GRPC_CORE_TRANSPORT_METADATA_H +#ifndef GRPC_CORE_LIB_TRANSPORT_METADATA_H +#define GRPC_CORE_LIB_TRANSPORT_METADATA_H #include #include @@ -153,4 +153,4 @@ int grpc_mdstr_is_bin_suffixed(grpc_mdstr *s); void grpc_mdctx_global_init(void); void grpc_mdctx_global_shutdown(void); -#endif /* GRPC_CORE_TRANSPORT_METADATA_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_METADATA_H */ diff --git a/src/core/lib/transport/metadata_batch.h b/src/core/lib/transport/metadata_batch.h index 9337b28328..4c9395e6c0 100644 --- a/src/core/lib/transport/metadata_batch.h +++ b/src/core/lib/transport/metadata_batch.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_METADATA_BATCH_H -#define GRPC_CORE_TRANSPORT_METADATA_BATCH_H +#ifndef GRPC_CORE_LIB_TRANSPORT_METADATA_BATCH_H +#define GRPC_CORE_LIB_TRANSPORT_METADATA_BATCH_H #include #include @@ -122,4 +122,4 @@ void grpc_metadata_batch_assert_ok(grpc_metadata_batch *comd); } while (0) #endif -#endif /* GRPC_CORE_TRANSPORT_METADATA_BATCH_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_METADATA_BATCH_H */ diff --git a/src/core/lib/transport/static_metadata.h b/src/core/lib/transport/static_metadata.h index 85442f8107..bfcb010387 100644 --- a/src/core/lib/transport/static_metadata.h +++ b/src/core/lib/transport/static_metadata.h @@ -43,8 +43,8 @@ * explanation of what's going on. */ -#ifndef GRPC_CORE_TRANSPORT_STATIC_METADATA_H -#define GRPC_CORE_TRANSPORT_STATIC_METADATA_H +#ifndef GRPC_CORE_LIB_TRANSPORT_STATIC_METADATA_H +#define GRPC_CORE_LIB_TRANSPORT_STATIC_METADATA_H #include "src/core/transport/metadata.h" @@ -405,4 +405,4 @@ extern const char *const grpc_static_metadata_strings[GRPC_STATIC_MDSTR_COUNT]; extern const uint8_t grpc_static_accept_encoding_metadata[8]; #define GRPC_MDELEM_ACCEPT_ENCODING_FOR_ALGORITHMS(algs) \ (&grpc_static_mdelem_table[grpc_static_accept_encoding_metadata[(algs)]]) -#endif /* GRPC_CORE_TRANSPORT_STATIC_METADATA_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_STATIC_METADATA_H */ diff --git a/src/core/lib/transport/transport.h b/src/core/lib/transport/transport.h index f43e56f23c..4174f049d5 100644 --- a/src/core/lib/transport/transport.h +++ b/src/core/lib/transport/transport.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_TRANSPORT_H -#define GRPC_CORE_TRANSPORT_TRANSPORT_H +#ifndef GRPC_CORE_LIB_TRANSPORT_TRANSPORT_H +#define GRPC_CORE_LIB_TRANSPORT_TRANSPORT_H #include @@ -239,4 +239,4 @@ void grpc_transport_destroy(grpc_exec_ctx *exec_ctx, grpc_transport *transport); char *grpc_transport_get_peer(grpc_exec_ctx *exec_ctx, grpc_transport *transport); -#endif /* GRPC_CORE_TRANSPORT_TRANSPORT_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_TRANSPORT_H */ diff --git a/src/core/lib/transport/transport_impl.h b/src/core/lib/transport/transport_impl.h index d9ecc4d2ba..60fd27a8dc 100644 --- a/src/core/lib/transport/transport_impl.h +++ b/src/core/lib/transport/transport_impl.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TRANSPORT_TRANSPORT_IMPL_H -#define GRPC_CORE_TRANSPORT_TRANSPORT_IMPL_H +#ifndef GRPC_CORE_LIB_TRANSPORT_TRANSPORT_IMPL_H +#define GRPC_CORE_LIB_TRANSPORT_TRANSPORT_IMPL_H #include "src/core/transport/transport.h" @@ -78,4 +78,4 @@ struct grpc_transport { const grpc_transport_vtable *vtable; }; -#endif /* GRPC_CORE_TRANSPORT_TRANSPORT_IMPL_H */ +#endif /* GRPC_CORE_LIB_TRANSPORT_TRANSPORT_IMPL_H */ diff --git a/src/core/lib/tsi/fake_transport_security.h b/src/core/lib/tsi/fake_transport_security.h index 6b8e596290..718c1a50db 100644 --- a/src/core/lib/tsi/fake_transport_security.h +++ b/src/core/lib/tsi/fake_transport_security.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TSI_FAKE_TRANSPORT_SECURITY_H -#define GRPC_CORE_TSI_FAKE_TRANSPORT_SECURITY_H +#ifndef GRPC_CORE_LIB_TSI_FAKE_TRANSPORT_SECURITY_H +#define GRPC_CORE_LIB_TSI_FAKE_TRANSPORT_SECURITY_H #include "src/core/tsi/transport_security_interface.h" @@ -58,4 +58,4 @@ tsi_frame_protector *tsi_create_fake_protector( } #endif -#endif /* GRPC_CORE_TSI_FAKE_TRANSPORT_SECURITY_H */ +#endif /* GRPC_CORE_LIB_TSI_FAKE_TRANSPORT_SECURITY_H */ diff --git a/src/core/lib/tsi/ssl_transport_security.h b/src/core/lib/tsi/ssl_transport_security.h index 612f5c64cc..441b010e4e 100644 --- a/src/core/lib/tsi/ssl_transport_security.h +++ b/src/core/lib/tsi/ssl_transport_security.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TSI_SSL_TRANSPORT_SECURITY_H -#define GRPC_CORE_TSI_SSL_TRANSPORT_SECURITY_H +#ifndef GRPC_CORE_LIB_TSI_SSL_TRANSPORT_SECURITY_H +#define GRPC_CORE_LIB_TSI_SSL_TRANSPORT_SECURITY_H #include "src/core/tsi/transport_security_interface.h" @@ -171,4 +171,4 @@ int tsi_ssl_peer_matches_name(const tsi_peer *peer, const char *name); } #endif -#endif /* GRPC_CORE_TSI_SSL_TRANSPORT_SECURITY_H */ +#endif /* GRPC_CORE_LIB_TSI_SSL_TRANSPORT_SECURITY_H */ diff --git a/src/core/lib/tsi/ssl_types.h b/src/core/lib/tsi/ssl_types.h index 6ea85fe6d4..c6e68c01ad 100644 --- a/src/core/lib/tsi/ssl_types.h +++ b/src/core/lib/tsi/ssl_types.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TSI_SSL_TYPES_H -#define GRPC_CORE_TSI_SSL_TYPES_H +#ifndef GRPC_CORE_LIB_TSI_SSL_TYPES_H +#define GRPC_CORE_LIB_TSI_SSL_TYPES_H /* A collection of macros to cast between various integer types that are * used differently between BoringSSL and OpenSSL: @@ -52,4 +52,4 @@ #define TSI_SIZE_AS_SIZE(x) ((int)(x)) #endif -#endif /* GRPC_CORE_TSI_SSL_TYPES_H */ +#endif /* GRPC_CORE_LIB_TSI_SSL_TYPES_H */ diff --git a/src/core/lib/tsi/transport_security.h b/src/core/lib/tsi/transport_security.h index ecc037193b..292af7ffb9 100644 --- a/src/core/lib/tsi/transport_security.h +++ b/src/core/lib/tsi/transport_security.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TSI_TRANSPORT_SECURITY_H -#define GRPC_CORE_TSI_TRANSPORT_SECURITY_H +#ifndef GRPC_CORE_LIB_TSI_TRANSPORT_SECURITY_H +#define GRPC_CORE_LIB_TSI_TRANSPORT_SECURITY_H #include "src/core/tsi/transport_security_interface.h" @@ -108,4 +108,4 @@ char *tsi_strdup(const char *src); /* Sadly, no strdup in C89. */ } #endif -#endif /* GRPC_CORE_TSI_TRANSPORT_SECURITY_H */ +#endif /* GRPC_CORE_LIB_TSI_TRANSPORT_SECURITY_H */ diff --git a/src/core/lib/tsi/transport_security_interface.h b/src/core/lib/tsi/transport_security_interface.h index 08501802f5..f88f1516a9 100644 --- a/src/core/lib/tsi/transport_security_interface.h +++ b/src/core/lib/tsi/transport_security_interface.h @@ -31,8 +31,8 @@ * */ -#ifndef GRPC_CORE_TSI_TRANSPORT_SECURITY_INTERFACE_H -#define GRPC_CORE_TSI_TRANSPORT_SECURITY_INTERFACE_H +#ifndef GRPC_CORE_LIB_TSI_TRANSPORT_SECURITY_INTERFACE_H +#define GRPC_CORE_LIB_TSI_TRANSPORT_SECURITY_INTERFACE_H #include #include @@ -341,4 +341,4 @@ void tsi_handshaker_destroy(tsi_handshaker *self); } #endif -#endif /* GRPC_CORE_TSI_TRANSPORT_SECURITY_INTERFACE_H */ +#endif /* GRPC_CORE_LIB_TSI_TRANSPORT_SECURITY_INTERFACE_H */ -- cgit v1.2.3 From 8a9fd52b712cf8aa415a4c2cdcd5aa6ac96bb698 Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Fri, 25 Mar 2016 17:09:29 -0700 Subject: Fix copyright --- src/core/lib/census/grpc_context.c | 2 +- src/core/lib/census/operation.c | 2 +- src/core/lib/census/tracing.c | 2 +- src/core/lib/channel/channel_stack.c | 2 +- src/core/lib/client_config/default_initial_connect_string.c | 2 +- src/core/lib/client_config/initial_connect_string.c | 2 +- src/core/lib/client_config/lb_policy_factory.c | 2 +- src/core/lib/client_config/lb_policy_registry.c | 2 +- src/core/lib/client_config/resolver.c | 2 +- src/core/lib/client_config/resolver_factory.c | 2 +- src/core/lib/client_config/resolver_registry.c | 2 +- src/core/lib/client_config/subchannel_factory.c | 2 +- src/core/lib/client_config/uri_parser.c | 2 +- src/core/lib/compression/message_compress.c | 2 +- src/core/lib/debug/trace.c | 2 +- src/core/lib/iomgr/endpoint.c | 2 +- src/core/lib/iomgr/socket_utils_posix.c | 2 +- src/core/lib/iomgr/time_averaged_stats.c | 2 +- src/core/lib/iomgr/wakeup_fd_eventfd.c | 2 +- src/core/lib/iomgr/workqueue_windows.c | 2 +- src/core/lib/json/json.c | 2 +- src/core/lib/json/json_reader.c | 2 +- src/core/lib/json/json_writer.c | 2 +- src/core/lib/profiling/stap_timers.c | 2 +- src/core/lib/profiling/timers.h | 2 +- src/core/lib/security/credentials_metadata.c | 2 +- src/core/lib/security/credentials_posix.c | 2 +- src/core/lib/security/credentials_win32.c | 2 +- src/core/lib/support/cpu_iphone.c | 2 +- src/core/lib/support/cpu_windows.c | 2 +- src/core/lib/support/log.c | 2 +- src/core/lib/support/murmur_hash.c | 2 +- src/core/lib/support/slice.c | 2 +- src/core/lib/support/slice_buffer.c | 2 +- src/core/lib/support/string.c | 2 +- src/core/lib/support/thd.c | 2 +- src/core/lib/support/time_precise.c | 2 +- src/core/lib/support/tls_pthread.c | 2 +- src/core/lib/surface/api_trace.c | 2 +- src/core/lib/surface/byte_buffer.c | 2 +- src/core/lib/surface/call_details.c | 2 +- src/core/lib/surface/metadata_array.c | 2 +- src/core/lib/transport/byte_stream.c | 2 +- src/core/lib/transport/chttp2/alpn.c | 2 +- src/core/lib/transport/chttp2/frame_goaway.c | 2 +- src/core/lib/transport/chttp2/frame_ping.c | 2 +- src/core/lib/transport/chttp2/frame_rst_stream.c | 2 +- src/core/lib/transport/chttp2/frame_settings.c | 2 +- src/core/lib/transport/chttp2/frame_window_update.c | 2 +- src/core/lib/transport/chttp2/hpack_table.c | 2 +- src/core/lib/transport/chttp2/incoming_metadata.c | 2 +- src/core/lib/transport/chttp2/status_conversion.c | 2 +- src/core/lib/transport/chttp2/stream_map.c | 2 +- src/core/lib/transport/chttp2/varint.c | 2 +- src/core/lib/transport/metadata_batch.c | 2 +- src/core/lib/tsi/transport_security.c | 2 +- 56 files changed, 56 insertions(+), 56 deletions(-) (limited to 'src/core/lib/client_config') diff --git a/src/core/lib/census/grpc_context.c b/src/core/lib/census/grpc_context.c index 4b61382a2c..09280da3d6 100644 --- a/src/core/lib/census/grpc_context.c +++ b/src/core/lib/census/grpc_context.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/census/operation.c b/src/core/lib/census/operation.c index 5c58704372..315f9c3534 100644 --- a/src/core/lib/census/operation.c +++ b/src/core/lib/census/operation.c @@ -1,5 +1,5 @@ /* - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/census/tracing.c b/src/core/lib/census/tracing.c index 3b5d6dab2b..e508996af3 100644 --- a/src/core/lib/census/tracing.c +++ b/src/core/lib/census/tracing.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/channel/channel_stack.c b/src/core/lib/channel/channel_stack.c index 3e61688364..39ff1aed5a 100644 --- a/src/core/lib/channel/channel_stack.c +++ b/src/core/lib/channel/channel_stack.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/client_config/default_initial_connect_string.c b/src/core/lib/client_config/default_initial_connect_string.c index 6a4e23e6f2..90b4f96327 100644 --- a/src/core/lib/client_config/default_initial_connect_string.c +++ b/src/core/lib/client_config/default_initial_connect_string.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/client_config/initial_connect_string.c b/src/core/lib/client_config/initial_connect_string.c index 19afa1675a..d199efebde 100644 --- a/src/core/lib/client_config/initial_connect_string.c +++ b/src/core/lib/client_config/initial_connect_string.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/client_config/lb_policy_factory.c b/src/core/lib/client_config/lb_policy_factory.c index e49de544e3..a261922659 100644 --- a/src/core/lib/client_config/lb_policy_factory.c +++ b/src/core/lib/client_config/lb_policy_factory.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/client_config/lb_policy_registry.c b/src/core/lib/client_config/lb_policy_registry.c index fc302e82d7..e836456151 100644 --- a/src/core/lib/client_config/lb_policy_registry.c +++ b/src/core/lib/client_config/lb_policy_registry.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/client_config/resolver.c b/src/core/lib/client_config/resolver.c index eda01e72ba..8c677978f8 100644 --- a/src/core/lib/client_config/resolver.c +++ b/src/core/lib/client_config/resolver.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/client_config/resolver_factory.c b/src/core/lib/client_config/resolver_factory.c index e7e9196ac4..6ee56f0063 100644 --- a/src/core/lib/client_config/resolver_factory.c +++ b/src/core/lib/client_config/resolver_factory.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/client_config/resolver_registry.c b/src/core/lib/client_config/resolver_registry.c index 89a945c2d3..a38b3d8995 100644 --- a/src/core/lib/client_config/resolver_registry.c +++ b/src/core/lib/client_config/resolver_registry.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/client_config/subchannel_factory.c b/src/core/lib/client_config/subchannel_factory.c index 2c64219e8b..8caeaf11bf 100644 --- a/src/core/lib/client_config/subchannel_factory.c +++ b/src/core/lib/client_config/subchannel_factory.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/client_config/uri_parser.c b/src/core/lib/client_config/uri_parser.c index cbdfffcf8e..c1b64778b1 100644 --- a/src/core/lib/client_config/uri_parser.c +++ b/src/core/lib/client_config/uri_parser.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/compression/message_compress.c b/src/core/lib/compression/message_compress.c index edc21a9eb7..c3a21ec19f 100644 --- a/src/core/lib/compression/message_compress.c +++ b/src/core/lib/compression/message_compress.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/debug/trace.c b/src/core/lib/debug/trace.c index 3b35d81cd8..42150b1bc3 100644 --- a/src/core/lib/debug/trace.c +++ b/src/core/lib/debug/trace.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/iomgr/endpoint.c b/src/core/lib/iomgr/endpoint.c index bd64707669..f1bdd0fc6c 100644 --- a/src/core/lib/iomgr/endpoint.c +++ b/src/core/lib/iomgr/endpoint.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/iomgr/socket_utils_posix.c b/src/core/lib/iomgr/socket_utils_posix.c index 3c56b46744..794a5804ac 100644 --- a/src/core/lib/iomgr/socket_utils_posix.c +++ b/src/core/lib/iomgr/socket_utils_posix.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/iomgr/time_averaged_stats.c b/src/core/lib/iomgr/time_averaged_stats.c index e075db4373..014162cc3b 100644 --- a/src/core/lib/iomgr/time_averaged_stats.c +++ b/src/core/lib/iomgr/time_averaged_stats.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/iomgr/wakeup_fd_eventfd.c b/src/core/lib/iomgr/wakeup_fd_eventfd.c index f67379e4fc..f4662965cd 100644 --- a/src/core/lib/iomgr/wakeup_fd_eventfd.c +++ b/src/core/lib/iomgr/wakeup_fd_eventfd.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/iomgr/workqueue_windows.c b/src/core/lib/iomgr/workqueue_windows.c index f9ca57557b..dd7fac8b35 100644 --- a/src/core/lib/iomgr/workqueue_windows.c +++ b/src/core/lib/iomgr/workqueue_windows.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/json/json.c b/src/core/lib/json/json.c index 96e11eebb1..b31ee49562 100644 --- a/src/core/lib/json/json.c +++ b/src/core/lib/json/json.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/json/json_reader.c b/src/core/lib/json/json_reader.c index 30da6f28f3..861323d10c 100644 --- a/src/core/lib/json/json_reader.c +++ b/src/core/lib/json/json_reader.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/json/json_writer.c b/src/core/lib/json/json_writer.c index 326ec2d431..abcb3efd98 100644 --- a/src/core/lib/json/json_writer.c +++ b/src/core/lib/json/json_writer.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/profiling/stap_timers.c b/src/core/lib/profiling/stap_timers.c index efcd1af4a1..d67541a339 100644 --- a/src/core/lib/profiling/stap_timers.c +++ b/src/core/lib/profiling/stap_timers.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/profiling/timers.h b/src/core/lib/profiling/timers.h index c8567e8137..1303593ffb 100644 --- a/src/core/lib/profiling/timers.h +++ b/src/core/lib/profiling/timers.h @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/security/credentials_metadata.c b/src/core/lib/security/credentials_metadata.c index b8a132f1ea..524c003eca 100644 --- a/src/core/lib/security/credentials_metadata.c +++ b/src/core/lib/security/credentials_metadata.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/security/credentials_posix.c b/src/core/lib/security/credentials_posix.c index 0c92bd4a96..488e60c3bc 100644 --- a/src/core/lib/security/credentials_posix.c +++ b/src/core/lib/security/credentials_posix.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/security/credentials_win32.c b/src/core/lib/security/credentials_win32.c index 8ee9f706a1..646b0c21d6 100644 --- a/src/core/lib/security/credentials_win32.c +++ b/src/core/lib/security/credentials_win32.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/support/cpu_iphone.c b/src/core/lib/support/cpu_iphone.c index 82b49b47bc..e83191bada 100644 --- a/src/core/lib/support/cpu_iphone.c +++ b/src/core/lib/support/cpu_iphone.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/support/cpu_windows.c b/src/core/lib/support/cpu_windows.c index ce32eb0a9d..0f84a9e5ea 100644 --- a/src/core/lib/support/cpu_windows.c +++ b/src/core/lib/support/cpu_windows.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/support/log.c b/src/core/lib/support/log.c index 04156a5b1f..cd6a0726cf 100644 --- a/src/core/lib/support/log.c +++ b/src/core/lib/support/log.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/support/murmur_hash.c b/src/core/lib/support/murmur_hash.c index a5261c0cc0..47e9777fec 100644 --- a/src/core/lib/support/murmur_hash.c +++ b/src/core/lib/support/murmur_hash.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/support/slice.c b/src/core/lib/support/slice.c index b9a7c77bda..cf3953ce4e 100644 --- a/src/core/lib/support/slice.c +++ b/src/core/lib/support/slice.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/support/slice_buffer.c b/src/core/lib/support/slice_buffer.c index 66f111d767..563e659dd7 100644 --- a/src/core/lib/support/slice_buffer.c +++ b/src/core/lib/support/slice_buffer.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/support/string.c b/src/core/lib/support/string.c index 1f541de40f..e8021ddaba 100644 --- a/src/core/lib/support/string.c +++ b/src/core/lib/support/string.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/support/thd.c b/src/core/lib/support/thd.c index 41daeb5d0e..d59aace38d 100644 --- a/src/core/lib/support/thd.c +++ b/src/core/lib/support/thd.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/support/time_precise.c b/src/core/lib/support/time_precise.c index a2cf74bc84..31ac47e0f8 100644 --- a/src/core/lib/support/time_precise.c +++ b/src/core/lib/support/time_precise.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/support/tls_pthread.c b/src/core/lib/support/tls_pthread.c index 9683a6e547..bdc7ed14ae 100644 --- a/src/core/lib/support/tls_pthread.c +++ b/src/core/lib/support/tls_pthread.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/surface/api_trace.c b/src/core/lib/surface/api_trace.c index 9f0b900d46..06c65c0610 100644 --- a/src/core/lib/surface/api_trace.c +++ b/src/core/lib/surface/api_trace.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/surface/byte_buffer.c b/src/core/lib/surface/byte_buffer.c index fb39c4531d..03071ef92c 100644 --- a/src/core/lib/surface/byte_buffer.c +++ b/src/core/lib/surface/byte_buffer.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/surface/call_details.c b/src/core/lib/surface/call_details.c index 60f0029819..dc5ea22ee7 100644 --- a/src/core/lib/surface/call_details.c +++ b/src/core/lib/surface/call_details.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/surface/metadata_array.c b/src/core/lib/surface/metadata_array.c index 4c7bf17835..57096326a3 100644 --- a/src/core/lib/surface/metadata_array.c +++ b/src/core/lib/surface/metadata_array.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/transport/byte_stream.c b/src/core/lib/transport/byte_stream.c index 8e6fb2cbef..cfba878dc4 100644 --- a/src/core/lib/transport/byte_stream.c +++ b/src/core/lib/transport/byte_stream.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/transport/chttp2/alpn.c b/src/core/lib/transport/chttp2/alpn.c index 69da4e6718..67fff21229 100644 --- a/src/core/lib/transport/chttp2/alpn.c +++ b/src/core/lib/transport/chttp2/alpn.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/transport/chttp2/frame_goaway.c b/src/core/lib/transport/chttp2/frame_goaway.c index 2fa525e989..45a8e2e270 100644 --- a/src/core/lib/transport/chttp2/frame_goaway.c +++ b/src/core/lib/transport/chttp2/frame_goaway.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/transport/chttp2/frame_ping.c b/src/core/lib/transport/chttp2/frame_ping.c index c6ab522283..d619edb2d6 100644 --- a/src/core/lib/transport/chttp2/frame_ping.c +++ b/src/core/lib/transport/chttp2/frame_ping.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/transport/chttp2/frame_rst_stream.c b/src/core/lib/transport/chttp2/frame_rst_stream.c index 754529e4b9..3b4aa623f2 100644 --- a/src/core/lib/transport/chttp2/frame_rst_stream.c +++ b/src/core/lib/transport/chttp2/frame_rst_stream.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/transport/chttp2/frame_settings.c b/src/core/lib/transport/chttp2/frame_settings.c index cc49dd4f69..9c5ad9f30e 100644 --- a/src/core/lib/transport/chttp2/frame_settings.c +++ b/src/core/lib/transport/chttp2/frame_settings.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/transport/chttp2/frame_window_update.c b/src/core/lib/transport/chttp2/frame_window_update.c index 62d9bac117..03b665c9cb 100644 --- a/src/core/lib/transport/chttp2/frame_window_update.c +++ b/src/core/lib/transport/chttp2/frame_window_update.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/transport/chttp2/hpack_table.c b/src/core/lib/transport/chttp2/hpack_table.c index f1ce3b84fd..bf836e0139 100644 --- a/src/core/lib/transport/chttp2/hpack_table.c +++ b/src/core/lib/transport/chttp2/hpack_table.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/transport/chttp2/incoming_metadata.c b/src/core/lib/transport/chttp2/incoming_metadata.c index 315bc2faa1..245d6ac15a 100644 --- a/src/core/lib/transport/chttp2/incoming_metadata.c +++ b/src/core/lib/transport/chttp2/incoming_metadata.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/transport/chttp2/status_conversion.c b/src/core/lib/transport/chttp2/status_conversion.c index bf214b017a..cb566230fc 100644 --- a/src/core/lib/transport/chttp2/status_conversion.c +++ b/src/core/lib/transport/chttp2/status_conversion.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/transport/chttp2/stream_map.c b/src/core/lib/transport/chttp2/stream_map.c index 555a16fb72..6c70229e42 100644 --- a/src/core/lib/transport/chttp2/stream_map.c +++ b/src/core/lib/transport/chttp2/stream_map.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/transport/chttp2/varint.c b/src/core/lib/transport/chttp2/varint.c index 1cc235e989..1b0cf15eba 100644 --- a/src/core/lib/transport/chttp2/varint.c +++ b/src/core/lib/transport/chttp2/varint.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/transport/metadata_batch.c b/src/core/lib/transport/metadata_batch.c index 1266862f82..2e27b461c9 100644 --- a/src/core/lib/transport/metadata_batch.c +++ b/src/core/lib/transport/metadata_batch.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/src/core/lib/tsi/transport_security.c b/src/core/lib/tsi/transport_security.c index db219a50a6..64aac2c05a 100644 --- a/src/core/lib/tsi/transport_security.c +++ b/src/core/lib/tsi/transport_security.c @@ -1,6 +1,6 @@ /* * - * Copyright 2015, Google Inc. + * Copyright 2015-2016, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without -- cgit v1.2.3 From 9533d042d4f52cc3cb04ea61ca179cce409e391c Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Fri, 25 Mar 2016 17:11:06 -0700 Subject: Fix includes --- src/core/lib/census/context.c | 2 +- src/core/lib/census/grpc_context.c | 4 +- src/core/lib/census/grpc_filter.c | 10 ++-- src/core/lib/census/grpc_filter.h | 2 +- src/core/lib/census/grpc_plugin.c | 8 +-- src/core/lib/census/mlog.c | 2 +- src/core/lib/channel/channel_args.c | 4 +- src/core/lib/channel/channel_stack.c | 2 +- src/core/lib/channel/channel_stack.h | 4 +- src/core/lib/channel/channel_stack_builder.c | 2 +- src/core/lib/channel/channel_stack_builder.h | 4 +- src/core/lib/channel/client_channel.c | 18 +++---- src/core/lib/channel/client_channel.h | 4 +- src/core/lib/channel/compress_filter.c | 14 ++--- src/core/lib/channel/compress_filter.h | 2 +- src/core/lib/channel/connected_channel.c | 8 +-- src/core/lib/channel/connected_channel.h | 2 +- src/core/lib/channel/http_client_filter.c | 8 +-- src/core/lib/channel/http_client_filter.h | 2 +- src/core/lib/channel/http_server_filter.c | 6 +-- src/core/lib/channel/http_server_filter.h | 2 +- src/core/lib/channel/subchannel_call_holder.c | 4 +- src/core/lib/channel/subchannel_call_holder.h | 2 +- src/core/lib/client_config/client_config.c | 2 +- src/core/lib/client_config/client_config.h | 2 +- src/core/lib/client_config/connector.c | 2 +- src/core/lib/client_config/connector.h | 6 +-- .../client_config/default_initial_connect_string.c | 2 +- .../lib/client_config/initial_connect_string.c | 2 +- .../lib/client_config/initial_connect_string.h | 2 +- .../client_config/lb_policies/load_balancer_api.c | 2 +- .../client_config/lb_policies/load_balancer_api.h | 4 +- .../lib/client_config/lb_policies/pick_first.c | 6 +-- .../lib/client_config/lb_policies/pick_first.h | 2 +- .../lib/client_config/lb_policies/round_robin.c | 4 +- .../lib/client_config/lb_policies/round_robin.h | 4 +- src/core/lib/client_config/lb_policy.c | 2 +- src/core/lib/client_config/lb_policy.h | 4 +- src/core/lib/client_config/lb_policy_factory.c | 2 +- src/core/lib/client_config/lb_policy_factory.h | 4 +- src/core/lib/client_config/lb_policy_registry.c | 2 +- src/core/lib/client_config/lb_policy_registry.h | 2 +- src/core/lib/client_config/resolver.c | 2 +- src/core/lib/client_config/resolver.h | 6 +-- src/core/lib/client_config/resolver_factory.c | 2 +- src/core/lib/client_config/resolver_factory.h | 6 +-- src/core/lib/client_config/resolver_registry.c | 2 +- src/core/lib/client_config/resolver_registry.h | 2 +- .../lib/client_config/resolvers/dns_resolver.c | 12 ++--- .../lib/client_config/resolvers/dns_resolver.h | 2 +- .../client_config/resolvers/sockaddr_resolver.c | 10 ++-- .../client_config/resolvers/sockaddr_resolver.h | 2 +- .../client_config/resolvers/zookeeper_resolver.c | 14 ++--- .../client_config/resolvers/zookeeper_resolver.h | 2 +- src/core/lib/client_config/subchannel.c | 24 ++++----- src/core/lib/client_config/subchannel.h | 6 +-- src/core/lib/client_config/subchannel_factory.c | 2 +- src/core/lib/client_config/subchannel_factory.h | 4 +- src/core/lib/client_config/subchannel_index.c | 4 +- src/core/lib/client_config/subchannel_index.h | 4 +- src/core/lib/client_config/uri_parser.c | 2 +- src/core/lib/compression/algorithm_metadata.h | 2 +- src/core/lib/compression/compression_algorithm.c | 6 +-- src/core/lib/compression/message_compress.c | 2 +- src/core/lib/debug/trace.c | 4 +- src/core/lib/http/format_request.c | 4 +- src/core/lib/http/format_request.h | 2 +- src/core/lib/http/httpcli.c | 18 +++---- src/core/lib/http/httpcli.h | 8 +-- src/core/lib/http/httpcli_security_connector.c | 8 +-- src/core/lib/http/parser.c | 2 +- src/core/lib/iomgr/closure.c | 2 +- src/core/lib/iomgr/endpoint.c | 2 +- src/core/lib/iomgr/endpoint.h | 4 +- src/core/lib/iomgr/endpoint_pair.h | 2 +- src/core/lib/iomgr/endpoint_pair_posix.c | 10 ++-- src/core/lib/iomgr/endpoint_pair_windows.c | 8 +-- src/core/lib/iomgr/exec_ctx.c | 4 +- src/core/lib/iomgr/exec_ctx.h | 2 +- src/core/lib/iomgr/executor.c | 4 +- src/core/lib/iomgr/executor.h | 2 +- src/core/lib/iomgr/fd_posix.c | 4 +- src/core/lib/iomgr/fd_posix.h | 4 +- src/core/lib/iomgr/iocp_windows.c | 8 +-- src/core/lib/iomgr/iocp_windows.h | 2 +- src/core/lib/iomgr/iomgr.c | 12 ++--- src/core/lib/iomgr/iomgr_internal.h | 2 +- src/core/lib/iomgr/iomgr_posix.c | 8 +-- src/core/lib/iomgr/iomgr_posix.h | 2 +- src/core/lib/iomgr/iomgr_windows.c | 8 +-- src/core/lib/iomgr/pollset.h | 2 +- .../lib/iomgr/pollset_multipoller_with_epoll.c | 8 +-- .../iomgr/pollset_multipoller_with_poll_posix.c | 10 ++-- src/core/lib/iomgr/pollset_posix.c | 12 ++--- src/core/lib/iomgr/pollset_posix.h | 8 +-- src/core/lib/iomgr/pollset_set.h | 2 +- src/core/lib/iomgr/pollset_set_posix.c | 4 +- src/core/lib/iomgr/pollset_set_posix.h | 4 +- src/core/lib/iomgr/pollset_set_windows.c | 2 +- src/core/lib/iomgr/pollset_set_windows.h | 2 +- src/core/lib/iomgr/pollset_windows.c | 8 +-- src/core/lib/iomgr/pollset_windows.h | 2 +- src/core/lib/iomgr/resolve_address.h | 4 +- src/core/lib/iomgr/resolve_address_posix.c | 16 +++--- src/core/lib/iomgr/resolve_address_windows.c | 14 ++--- src/core/lib/iomgr/sockaddr.h | 4 +- src/core/lib/iomgr/sockaddr_utils.c | 6 +-- src/core/lib/iomgr/sockaddr_utils.h | 2 +- src/core/lib/iomgr/socket_utils_common_posix.c | 6 +-- src/core/lib/iomgr/socket_utils_linux.c | 2 +- src/core/lib/iomgr/socket_utils_posix.c | 2 +- src/core/lib/iomgr/socket_windows.c | 10 ++-- src/core/lib/iomgr/socket_windows.h | 4 +- src/core/lib/iomgr/tcp_client.h | 6 +-- src/core/lib/iomgr/tcp_client_posix.c | 20 ++++---- src/core/lib/iomgr/tcp_client_windows.c | 16 +++--- src/core/lib/iomgr/tcp_posix.c | 12 ++--- src/core/lib/iomgr/tcp_posix.h | 4 +- src/core/lib/iomgr/tcp_server.h | 4 +- src/core/lib/iomgr/tcp_server_posix.c | 16 +++--- src/core/lib/iomgr/tcp_server_windows.c | 12 ++--- src/core/lib/iomgr/tcp_windows.c | 14 ++--- src/core/lib/iomgr/tcp_windows.h | 4 +- src/core/lib/iomgr/time_averaged_stats.c | 2 +- src/core/lib/iomgr/timer.c | 6 +-- src/core/lib/iomgr/timer.h | 4 +- src/core/lib/iomgr/timer_heap.c | 2 +- src/core/lib/iomgr/timer_heap.h | 2 +- src/core/lib/iomgr/udp_server.c | 16 +++--- src/core/lib/iomgr/udp_server.h | 4 +- src/core/lib/iomgr/unix_sockets_posix.c | 2 +- src/core/lib/iomgr/unix_sockets_posix.h | 8 +-- src/core/lib/iomgr/unix_sockets_posix_noop.c | 2 +- src/core/lib/iomgr/wakeup_fd_eventfd.c | 4 +- src/core/lib/iomgr/wakeup_fd_nospecial.c | 2 +- src/core/lib/iomgr/wakeup_fd_pipe.c | 4 +- src/core/lib/iomgr/wakeup_fd_pipe.h | 2 +- src/core/lib/iomgr/wakeup_fd_posix.c | 4 +- src/core/lib/iomgr/workqueue.h | 12 ++--- src/core/lib/iomgr/workqueue_posix.c | 6 +-- src/core/lib/iomgr/workqueue_posix.h | 2 +- src/core/lib/iomgr/workqueue_windows.c | 2 +- src/core/lib/json/json.c | 2 +- src/core/lib/json/json.h | 2 +- src/core/lib/json/json_reader.c | 2 +- src/core/lib/json/json_reader.h | 2 +- src/core/lib/json/json_string.c | 6 +-- src/core/lib/json/json_writer.c | 2 +- src/core/lib/json/json_writer.h | 2 +- src/core/lib/profiling/basic_timers.c | 2 +- src/core/lib/profiling/stap_timers.c | 4 +- src/core/lib/proto/grpc/lb/v0/load_balancer.pb.c | 2 +- src/core/lib/security/auth_filters.h | 2 +- src/core/lib/security/b64.c | 2 +- src/core/lib/security/client_auth_filter.c | 16 +++--- src/core/lib/security/credentials.c | 18 +++---- src/core/lib/security/credentials.h | 10 ++-- src/core/lib/security/credentials_metadata.c | 2 +- src/core/lib/security/credentials_posix.c | 6 +-- src/core/lib/security/credentials_win32.c | 6 +-- src/core/lib/security/google_default_credentials.c | 12 ++--- src/core/lib/security/handshake.c | 6 +-- src/core/lib/security/handshake.h | 4 +- src/core/lib/security/json_token.c | 6 +-- src/core/lib/security/json_token.h | 2 +- src/core/lib/security/jwt_verifier.c | 8 +-- src/core/lib/security/jwt_verifier.h | 4 +- src/core/lib/security/secure_endpoint.c | 8 +-- src/core/lib/security/secure_endpoint.h | 2 +- src/core/lib/security/security_connector.c | 22 ++++---- src/core/lib/security/security_connector.h | 6 +-- src/core/lib/security/security_context.c | 8 +-- src/core/lib/security/security_context.h | 4 +- src/core/lib/security/server_auth_filter.c | 6 +-- src/core/lib/security/server_secure_chttp2.c | 24 ++++----- src/core/lib/statistics/census_init.c | 6 +-- src/core/lib/statistics/census_log.c | 2 +- src/core/lib/statistics/census_rpc_stats.c | 14 ++--- src/core/lib/statistics/census_rpc_stats.h | 2 +- src/core/lib/statistics/census_tracing.c | 8 +-- src/core/lib/statistics/census_tracing.h | 2 +- src/core/lib/statistics/hash_table.c | 2 +- src/core/lib/statistics/window_stats.c | 2 +- src/core/lib/support/alloc.c | 2 +- src/core/lib/support/backoff.c | 2 +- src/core/lib/support/cmdline.c | 2 +- src/core/lib/support/env_linux.c | 4 +- src/core/lib/support/env_posix.c | 4 +- src/core/lib/support/env_win32.c | 4 +- src/core/lib/support/host_port.c | 2 +- src/core/lib/support/load_file.c | 6 +-- src/core/lib/support/log_win32.c | 4 +- src/core/lib/support/murmur_hash.c | 2 +- src/core/lib/support/stack_lockfree.c | 2 +- src/core/lib/support/string.c | 2 +- src/core/lib/support/string_win32.c | 2 +- src/core/lib/support/subprocess_windows.c | 4 +- src/core/lib/support/sync_posix.c | 2 +- src/core/lib/support/time_posix.c | 2 +- src/core/lib/support/time_win32.c | 2 +- src/core/lib/support/tmpfile_posix.c | 4 +- src/core/lib/support/tmpfile_win32.c | 4 +- src/core/lib/surface/alarm.c | 4 +- src/core/lib/surface/api_trace.c | 2 +- src/core/lib/surface/api_trace.h | 2 +- src/core/lib/surface/byte_buffer_reader.c | 2 +- src/core/lib/surface/call.c | 20 ++++---- src/core/lib/surface/call.h | 8 +-- src/core/lib/surface/call_details.c | 2 +- src/core/lib/surface/call_log_batch.c | 4 +- src/core/lib/surface/channel.c | 18 +++---- src/core/lib/surface/channel.h | 6 +-- src/core/lib/surface/channel_connectivity.c | 10 ++-- src/core/lib/surface/channel_create.c | 20 ++++---- src/core/lib/surface/channel_init.c | 2 +- src/core/lib/surface/channel_init.h | 6 +-- src/core/lib/surface/channel_ping.c | 6 +-- src/core/lib/surface/channel_stack_type.c | 2 +- src/core/lib/surface/completion_queue.c | 18 +++---- src/core/lib/surface/completion_queue.h | 2 +- src/core/lib/surface/event_string.c | 4 +- src/core/lib/surface/init.c | 60 +++++++++++----------- src/core/lib/surface/init_secure.c | 16 +++--- src/core/lib/surface/init_unsecure.c | 2 +- src/core/lib/surface/lame_client.c | 12 ++--- src/core/lib/surface/lame_client.h | 2 +- src/core/lib/surface/metadata_array.c | 2 +- src/core/lib/surface/secure_channel_create.c | 22 ++++---- src/core/lib/surface/server.c | 26 +++++----- src/core/lib/surface/server.h | 4 +- src/core/lib/surface/server_chttp2.c | 12 ++--- src/core/lib/surface/surface_trace.h | 4 +- src/core/lib/transport/byte_stream.c | 2 +- src/core/lib/transport/byte_stream.h | 2 +- src/core/lib/transport/chttp2/alpn.c | 2 +- src/core/lib/transport/chttp2/bin_encoder.c | 4 +- src/core/lib/transport/chttp2/frame_data.c | 8 +-- src/core/lib/transport/chttp2/frame_data.h | 6 +-- src/core/lib/transport/chttp2/frame_goaway.c | 4 +- src/core/lib/transport/chttp2/frame_goaway.h | 4 +- src/core/lib/transport/chttp2/frame_ping.c | 4 +- src/core/lib/transport/chttp2/frame_ping.h | 4 +- src/core/lib/transport/chttp2/frame_rst_stream.c | 6 +-- src/core/lib/transport/chttp2/frame_rst_stream.h | 4 +- src/core/lib/transport/chttp2/frame_settings.c | 12 ++--- src/core/lib/transport/chttp2/frame_settings.h | 4 +- .../lib/transport/chttp2/frame_window_update.c | 4 +- .../lib/transport/chttp2/frame_window_update.h | 4 +- src/core/lib/transport/chttp2/hpack_encoder.c | 12 ++--- src/core/lib/transport/chttp2/hpack_encoder.h | 6 +-- src/core/lib/transport/chttp2/hpack_parser.c | 10 ++-- src/core/lib/transport/chttp2/hpack_parser.h | 8 +-- src/core/lib/transport/chttp2/hpack_table.c | 4 +- src/core/lib/transport/chttp2/hpack_table.h | 2 +- src/core/lib/transport/chttp2/huffsyms.c | 2 +- src/core/lib/transport/chttp2/incoming_metadata.c | 4 +- src/core/lib/transport/chttp2/incoming_metadata.h | 2 +- src/core/lib/transport/chttp2/internal.h | 28 +++++----- src/core/lib/transport/chttp2/parsing.c | 12 ++--- src/core/lib/transport/chttp2/status_conversion.c | 2 +- src/core/lib/transport/chttp2/status_conversion.h | 2 +- src/core/lib/transport/chttp2/stream_lists.c | 2 +- src/core/lib/transport/chttp2/stream_map.c | 2 +- src/core/lib/transport/chttp2/timeout_encoding.c | 4 +- src/core/lib/transport/chttp2/timeout_encoding.h | 2 +- src/core/lib/transport/chttp2/varint.c | 2 +- src/core/lib/transport/chttp2/writing.c | 6 +-- src/core/lib/transport/chttp2_transport.c | 18 +++---- src/core/lib/transport/chttp2_transport.h | 4 +- src/core/lib/transport/connectivity_state.c | 2 +- src/core/lib/transport/connectivity_state.h | 2 +- src/core/lib/transport/metadata.c | 14 ++--- src/core/lib/transport/metadata_batch.c | 4 +- src/core/lib/transport/metadata_batch.h | 2 +- src/core/lib/transport/static_metadata.c | 2 +- src/core/lib/transport/static_metadata.h | 2 +- src/core/lib/transport/transport.c | 4 +- src/core/lib/transport/transport.h | 10 ++-- src/core/lib/transport/transport_impl.h | 2 +- src/core/lib/transport/transport_op_string.c | 4 +- src/core/lib/tsi/fake_transport_security.c | 4 +- src/core/lib/tsi/fake_transport_security.h | 2 +- src/core/lib/tsi/ssl_transport_security.c | 6 +-- src/core/lib/tsi/ssl_transport_security.h | 2 +- src/core/lib/tsi/transport_security.c | 2 +- src/core/lib/tsi/transport_security.h | 2 +- src/cpp/client/channel.cc | 2 +- src/cpp/client/client_context.cc | 2 +- src/cpp/common/channel_arguments.cc | 2 +- src/cpp/common/core_codegen.cc | 2 +- src/cpp/common/secure_channel_arguments.cc | 2 +- src/cpp/server/server.cc | 2 +- src/cpp/server/server_context.cc | 4 +- src/csharp/ext/grpc_csharp_ext.c | 2 +- test/core/bad_client/bad_client.c | 14 ++--- test/core/bad_client/tests/badreq.c | 2 +- test/core/bad_client/tests/connection_prefix.c | 2 +- test/core/bad_client/tests/headers.c | 2 +- .../core/bad_client/tests/initial_settings_frame.c | 2 +- .../bad_client/tests/server_registered_method.c | 2 +- test/core/bad_client/tests/simple_request.c | 2 +- test/core/bad_client/tests/unknown_frame.c | 2 +- test/core/bad_client/tests/window_overflow.c | 2 +- test/core/bad_ssl/bad_ssl_test.c | 4 +- test/core/bad_ssl/servers/alpn.c | 2 +- test/core/bad_ssl/servers/cert.c | 2 +- test/core/census/mlog_test.c | 2 +- test/core/channel/channel_args_test.c | 2 +- test/core/channel/channel_stack_test.c | 2 +- test/core/client_config/lb_policies_test.c | 14 ++--- .../resolvers/dns_resolver_connectivity_test.c | 6 +-- .../client_config/resolvers/dns_resolver_test.c | 4 +- .../resolvers/sockaddr_resolver_test.c | 4 +- .../set_initial_connect_string_test.c | 8 +-- test/core/client_config/uri_parser_test.c | 2 +- test/core/compression/algorithm_test.c | 4 +- test/core/compression/message_compress_test.c | 4 +- test/core/end2end/cq_verifier.c | 4 +- test/core/end2end/dualstack_socket_test.c | 6 +-- test/core/end2end/fixtures/h2_census.c | 14 ++--- test/core/end2end/fixtures/h2_compress.c | 14 ++--- test/core/end2end/fixtures/h2_fakesec.c | 4 +- test/core/end2end/fixtures/h2_full+pipe.c | 14 ++--- test/core/end2end/fixtures/h2_full+poll+pipe.c | 16 +++--- test/core/end2end/fixtures/h2_full+poll.c | 14 ++--- test/core/end2end/fixtures/h2_full+trace.c | 14 ++--- test/core/end2end/fixtures/h2_full.c | 12 ++--- test/core/end2end/fixtures/h2_oauth2.c | 6 +-- test/core/end2end/fixtures/h2_proxy.c | 12 ++--- test/core/end2end/fixtures/h2_sockpair+trace.c | 22 ++++---- test/core/end2end/fixtures/h2_sockpair.c | 20 ++++---- test/core/end2end/fixtures/h2_sockpair_1byte.c | 20 ++++---- test/core/end2end/fixtures/h2_ssl+poll.c | 12 ++--- test/core/end2end/fixtures/h2_ssl.c | 10 ++-- test/core/end2end/fixtures/h2_ssl_proxy.c | 10 ++-- test/core/end2end/fixtures/h2_uds+poll.c | 16 +++--- test/core/end2end/fixtures/h2_uds.c | 14 ++--- test/core/end2end/tests/bad_hostname.c | 2 +- test/core/end2end/tests/call_creds.c | 4 +- test/core/end2end/tests/cancel_with_status.c | 2 +- test/core/end2end/tests/compressed_payload.c | 6 +-- test/core/end2end/tests/default_host.c | 2 +- test/core/end2end/tests/empty_batch.c | 2 +- test/core/end2end/tests/high_initial_seqno.c | 2 +- test/core/end2end/tests/hpack_size.c | 2 +- test/core/end2end/tests/negative_deadline.c | 2 +- test/core/end2end/tests/registered_call.c | 2 +- test/core/end2end/tests/request_with_flags.c | 2 +- test/core/end2end/tests/server_finishes_request.c | 2 +- test/core/end2end/tests/simple_request.c | 2 +- test/core/fling/client.c | 2 +- test/core/fling/fling_stream_test.c | 2 +- test/core/fling/fling_test.c | 2 +- test/core/fling/server.c | 2 +- test/core/http/format_request_test.c | 2 +- test/core/http/httpcli_test.c | 4 +- test/core/http/httpscli_test.c | 4 +- test/core/http/parser_test.c | 2 +- test/core/iomgr/endpoint_pair_test.c | 4 +- test/core/iomgr/endpoint_tests.h | 2 +- test/core/iomgr/fd_conservation_posix_test.c | 4 +- test/core/iomgr/fd_posix_test.c | 4 +- test/core/iomgr/resolve_address_test.c | 4 +- test/core/iomgr/sockaddr_utils_test.c | 2 +- test/core/iomgr/socket_utils_test.c | 2 +- test/core/iomgr/tcp_client_posix_test.c | 8 +-- test/core/iomgr/tcp_posix_test.c | 2 +- test/core/iomgr/tcp_server_posix_test.c | 6 +-- test/core/iomgr/time_averaged_stats_test.c | 2 +- test/core/iomgr/timer_heap_test.c | 2 +- test/core/iomgr/timer_list_test.c | 2 +- test/core/iomgr/udp_server_test.c | 6 +-- test/core/iomgr/workqueue_test.c | 2 +- test/core/json/json_rewrite.c | 4 +- test/core/json/json_rewrite_test.c | 4 +- test/core/json/json_stream_error_test.c | 4 +- test/core/json/json_test.c | 4 +- test/core/network_benchmarks/low_level_ping_pong.c | 2 +- test/core/profiling/timers_test.c | 2 +- test/core/security/auth_context_test.c | 4 +- test/core/security/b64_test.c | 2 +- test/core/security/create_jwt.c | 6 +-- test/core/security/credentials_test.c | 12 ++--- test/core/security/fetch_oauth2.c | 4 +- test/core/security/json_token_test.c | 6 +-- test/core/security/jwt_verifier_test.c | 8 +-- test/core/security/oauth2_utils.c | 2 +- test/core/security/oauth2_utils.h | 2 +- .../security/print_google_default_creds_token.c | 4 +- test/core/security/secure_endpoint_test.c | 8 +-- test/core/security/security_connector_test.c | 14 ++--- test/core/security/verify_jwt.c | 2 +- test/core/statistics/census_log_tests.c | 2 +- test/core/statistics/census_stub_test.c | 4 +- test/core/statistics/hash_table_test.c | 6 +-- test/core/statistics/rpc_stats_test.c | 6 +-- test/core/statistics/trace_test.c | 6 +-- test/core/statistics/window_stats_test.c | 2 +- test/core/support/backoff_test.c | 2 +- test/core/support/env_test.c | 4 +- test/core/support/load_file_test.c | 6 +-- test/core/support/murmur_hash_test.c | 2 +- test/core/support/stack_lockfree_test.c | 2 +- test/core/support/string_test.c | 2 +- test/core/surface/byte_buffer_reader_test.c | 2 +- test/core/surface/channel_create_test.c | 2 +- test/core/surface/completion_queue_test.c | 4 +- test/core/surface/lame_client_test.c | 8 +-- test/core/surface/secure_channel_create_test.c | 8 +-- test/core/surface/server_chttp2_test.c | 4 +- test/core/transport/chttp2/alpn_test.c | 2 +- test/core/transport/chttp2/bin_encoder_test.c | 4 +- test/core/transport/chttp2/hpack_encoder_test.c | 8 +-- test/core/transport/chttp2/hpack_parser_test.c | 2 +- test/core/transport/chttp2/hpack_table_test.c | 4 +- .../core/transport/chttp2/status_conversion_test.c | 2 +- test/core/transport/chttp2/stream_map_test.c | 2 +- test/core/transport/chttp2/timeout_encoding_test.c | 4 +- test/core/transport/chttp2/varint_test.c | 2 +- test/core/transport/connectivity_state_test.c | 2 +- test/core/transport/metadata_test.c | 6 +-- test/core/tsi/transport_security_test.c | 8 +-- test/core/util/port_posix.c | 4 +- test/core/util/port_server_client.c | 2 +- test/core/util/port_windows.c | 6 +-- test/core/util/reconnect_server.c | 6 +-- test/core/util/test_config.c | 2 +- test/core/util/test_tcp_server.c | 6 +-- test/core/util/test_tcp_server.h | 2 +- test/cpp/common/auth_property_iterator_test.cc | 2 +- test/cpp/common/secure_auth_context_test.cc | 2 +- test/cpp/end2end/async_end2end_test.cc | 2 +- test/cpp/end2end/end2end_test.cc | 2 +- test/cpp/end2end/shutdown_test.cc | 2 +- test/cpp/end2end/thread_stress_test.cc | 2 +- test/cpp/end2end/zookeeper_test.cc | 2 +- test/cpp/grpclb/grpclb_api_test.cc | 2 +- test/cpp/interop/client_helper.h | 2 +- test/cpp/interop/interop_client.cc | 2 +- test/cpp/interop/interop_test.cc | 4 +- test/cpp/interop/server_helper.cc | 2 +- test/cpp/qps/client_sync.cc | 2 +- test/cpp/qps/driver.cc | 2 +- test/cpp/qps/qps_test_with_poll.cc | 2 +- 444 files changed, 1185 insertions(+), 1185 deletions(-) (limited to 'src/core/lib/client_config') diff --git a/src/core/lib/census/context.c b/src/core/lib/census/context.c index 89b8ee0b39..5a118f46a9 100644 --- a/src/core/lib/census/context.c +++ b/src/core/lib/census/context.c @@ -38,7 +38,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" // Functions in this file support the public context API, including // encoding/decoding as part of context propagation across RPC's. The overall diff --git a/src/core/lib/census/grpc_context.c b/src/core/lib/census/grpc_context.c index 09280da3d6..457c176355 100644 --- a/src/core/lib/census/grpc_context.c +++ b/src/core/lib/census/grpc_context.c @@ -33,8 +33,8 @@ #include #include -#include "src/core/surface/api_trace.h" -#include "src/core/surface/call.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/call.h" void grpc_census_call_set_context(grpc_call *call, census_context *context) { GRPC_API_TRACE("grpc_census_call_set_context(call=%p, census_context=%p)", 2, diff --git a/src/core/lib/census/grpc_filter.c b/src/core/lib/census/grpc_filter.c index 11120a28d1..d27d789aa1 100644 --- a/src/core/lib/census/grpc_filter.c +++ b/src/core/lib/census/grpc_filter.c @@ -31,7 +31,7 @@ * */ -#include "src/core/census/grpc_filter.h" +#include "src/core/lib/census/grpc_filter.h" #include #include @@ -42,10 +42,10 @@ #include #include -#include "src/core/channel/channel_stack.h" -#include "src/core/statistics/census_interface.h" -#include "src/core/statistics/census_rpc_stats.h" -#include "src/core/transport/static_metadata.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/statistics/census_interface.h" +#include "src/core/lib/statistics/census_rpc_stats.h" +#include "src/core/lib/transport/static_metadata.h" typedef struct call_data { census_op_id op_id; diff --git a/src/core/lib/census/grpc_filter.h b/src/core/lib/census/grpc_filter.h index e71346b357..7ceafe56e4 100644 --- a/src/core/lib/census/grpc_filter.h +++ b/src/core/lib/census/grpc_filter.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_CENSUS_GRPC_FILTER_H #define GRPC_CORE_LIB_CENSUS_GRPC_FILTER_H -#include "src/core/channel/channel_stack.h" +#include "src/core/lib/channel/channel_stack.h" /* Census filters: provides tracing and stats collection functionalities. It needs to reside right below the surface filter in the channel stack. */ diff --git a/src/core/lib/census/grpc_plugin.c b/src/core/lib/census/grpc_plugin.c index 3ca9400f7e..12aca76745 100644 --- a/src/core/lib/census/grpc_plugin.c +++ b/src/core/lib/census/grpc_plugin.c @@ -31,15 +31,15 @@ * */ -#include "src/core/census/grpc_plugin.h" +#include "src/core/lib/census/grpc_plugin.h" #include #include -#include "src/core/census/grpc_filter.h" -#include "src/core/channel/channel_stack_builder.h" -#include "src/core/surface/channel_init.h" +#include "src/core/lib/census/grpc_filter.h" +#include "src/core/lib/channel/channel_stack_builder.h" +#include "src/core/lib/surface/channel_init.h" static bool maybe_add_census_filter(grpc_channel_stack_builder *builder, void *arg_must_be_null) { diff --git a/src/core/lib/census/mlog.c b/src/core/lib/census/mlog.c index a2cc46d3f2..9d47e80297 100644 --- a/src/core/lib/census/mlog.c +++ b/src/core/lib/census/mlog.c @@ -88,7 +88,7 @@ // include the name of the structure, which will be passed as the first // argument. E.g. cl_block_initialize() will initialize a cl_block. -#include "src/core/census/mlog.h" +#include "src/core/lib/census/mlog.h" #include #include #include diff --git a/src/core/lib/channel/channel_args.c b/src/core/lib/channel/channel_args.c index e0382fa0d9..1a02f1f4aa 100644 --- a/src/core/lib/channel/channel_args.c +++ b/src/core/lib/channel/channel_args.c @@ -31,9 +31,9 @@ * */ -#include "src/core/channel/channel_args.h" +#include "src/core/lib/channel/channel_args.h" #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include #include diff --git a/src/core/lib/channel/channel_stack.c b/src/core/lib/channel/channel_stack.c index 39ff1aed5a..52283e35fa 100644 --- a/src/core/lib/channel/channel_stack.c +++ b/src/core/lib/channel/channel_stack.c @@ -31,7 +31,7 @@ * */ -#include "src/core/channel/channel_stack.h" +#include "src/core/lib/channel/channel_stack.h" #include #include diff --git a/src/core/lib/channel/channel_stack.h b/src/core/lib/channel/channel_stack.h index d91a65cb70..b29bee411d 100644 --- a/src/core/lib/channel/channel_stack.h +++ b/src/core/lib/channel/channel_stack.h @@ -45,8 +45,8 @@ #include #include -#include "src/core/debug/trace.h" -#include "src/core/transport/transport.h" +#include "src/core/lib/debug/trace.h" +#include "src/core/lib/transport/transport.h" typedef struct grpc_channel_element grpc_channel_element; typedef struct grpc_call_element grpc_call_element; diff --git a/src/core/lib/channel/channel_stack_builder.c b/src/core/lib/channel/channel_stack_builder.c index 1b1004e5f9..1ce0c4e07f 100644 --- a/src/core/lib/channel/channel_stack_builder.c +++ b/src/core/lib/channel/channel_stack_builder.c @@ -31,7 +31,7 @@ * */ -#include "src/core/channel/channel_stack_builder.h" +#include "src/core/lib/channel/channel_stack_builder.h" #include diff --git a/src/core/lib/channel/channel_stack_builder.h b/src/core/lib/channel/channel_stack_builder.h index ca285a9b23..8532c4462a 100644 --- a/src/core/lib/channel/channel_stack_builder.h +++ b/src/core/lib/channel/channel_stack_builder.h @@ -36,8 +36,8 @@ #include -#include "src/core/channel/channel_args.h" -#include "src/core/channel/channel_stack.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/channel/channel_stack.h" /// grpc_channel_stack_builder offers a programmatic interface to selected /// and order channel filters diff --git a/src/core/lib/channel/client_channel.c b/src/core/lib/channel/client_channel.c index ad1ded9ab7..9fdf803ecf 100644 --- a/src/core/lib/channel/client_channel.c +++ b/src/core/lib/channel/client_channel.c @@ -31,7 +31,7 @@ * */ -#include "src/core/channel/client_channel.h" +#include "src/core/lib/channel/client_channel.h" #include #include @@ -41,14 +41,14 @@ #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/subchannel_call_holder.h" -#include "src/core/iomgr/iomgr.h" -#include "src/core/profiling/timers.h" -#include "src/core/support/string.h" -#include "src/core/surface/channel.h" -#include "src/core/transport/connectivity_state.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/subchannel_call_holder.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/transport/connectivity_state.h" /* Client channel implementation */ diff --git a/src/core/lib/channel/client_channel.h b/src/core/lib/channel/client_channel.h index dacdd3bb69..8777796fb6 100644 --- a/src/core/lib/channel/client_channel.h +++ b/src/core/lib/channel/client_channel.h @@ -34,8 +34,8 @@ #ifndef GRPC_CORE_LIB_CHANNEL_CLIENT_CHANNEL_H #define GRPC_CORE_LIB_CHANNEL_CLIENT_CHANNEL_H -#include "src/core/channel/channel_stack.h" -#include "src/core/client_config/resolver.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/client_config/resolver.h" /* A client channel is a channel that begins disconnected, and can connect to some endpoint on demand. If that endpoint disconnects, it will be diff --git a/src/core/lib/channel/compress_filter.c b/src/core/lib/channel/compress_filter.c index 6f5a9740ad..04bb7cc76f 100644 --- a/src/core/lib/channel/compress_filter.c +++ b/src/core/lib/channel/compress_filter.c @@ -39,13 +39,13 @@ #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/channel/compress_filter.h" -#include "src/core/compression/algorithm_metadata.h" -#include "src/core/compression/message_compress.h" -#include "src/core/profiling/timers.h" -#include "src/core/support/string.h" -#include "src/core/transport/static_metadata.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/channel/compress_filter.h" +#include "src/core/lib/compression/algorithm_metadata.h" +#include "src/core/lib/compression/message_compress.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/transport/static_metadata.h" typedef struct call_data { gpr_slice_buffer slices; /**< Buffers up input slices to be compressed */ diff --git a/src/core/lib/channel/compress_filter.h b/src/core/lib/channel/compress_filter.h index 73eb271731..9010074335 100644 --- a/src/core/lib/channel/compress_filter.h +++ b/src/core/lib/channel/compress_filter.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_CHANNEL_COMPRESS_FILTER_H #define GRPC_CORE_LIB_CHANNEL_COMPRESS_FILTER_H -#include "src/core/channel/channel_stack.h" +#include "src/core/lib/channel/channel_stack.h" #define GRPC_COMPRESS_REQUEST_ALGORITHM_KEY "grpc-internal-encoding-request" diff --git a/src/core/lib/channel/connected_channel.c b/src/core/lib/channel/connected_channel.c index df11d54297..5e3a8974ce 100644 --- a/src/core/lib/channel/connected_channel.c +++ b/src/core/lib/channel/connected_channel.c @@ -31,7 +31,7 @@ * */ -#include "src/core/channel/connected_channel.h" +#include "src/core/lib/channel/connected_channel.h" #include #include @@ -41,9 +41,9 @@ #include #include #include -#include "src/core/profiling/timers.h" -#include "src/core/support/string.h" -#include "src/core/transport/transport.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/transport/transport.h" #define MAX_BUFFER_LENGTH 8192 diff --git a/src/core/lib/channel/connected_channel.h b/src/core/lib/channel/connected_channel.h index 971bc913bc..4f20b751cc 100644 --- a/src/core/lib/channel/connected_channel.h +++ b/src/core/lib/channel/connected_channel.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_CHANNEL_CONNECTED_CHANNEL_H #define GRPC_CORE_LIB_CHANNEL_CONNECTED_CHANNEL_H -#include "src/core/channel/channel_stack_builder.h" +#include "src/core/lib/channel/channel_stack_builder.h" bool grpc_add_connected_filter(grpc_channel_stack_builder *builder, void *arg_must_be_null); diff --git a/src/core/lib/channel/http_client_filter.c b/src/core/lib/channel/http_client_filter.c index 582427daf9..7dbac38414 100644 --- a/src/core/lib/channel/http_client_filter.c +++ b/src/core/lib/channel/http_client_filter.c @@ -30,14 +30,14 @@ * */ -#include "src/core/channel/http_client_filter.h" +#include "src/core/lib/channel/http_client_filter.h" #include #include #include #include -#include "src/core/profiling/timers.h" -#include "src/core/support/string.h" -#include "src/core/transport/static_metadata.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/transport/static_metadata.h" typedef struct call_data { grpc_linked_mdelem method; diff --git a/src/core/lib/channel/http_client_filter.h b/src/core/lib/channel/http_client_filter.h index d2ccdda0a4..418426e9cc 100644 --- a/src/core/lib/channel/http_client_filter.h +++ b/src/core/lib/channel/http_client_filter.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_CHANNEL_HTTP_CLIENT_FILTER_H #define GRPC_CORE_LIB_CHANNEL_HTTP_CLIENT_FILTER_H -#include "src/core/channel/channel_stack.h" +#include "src/core/lib/channel/channel_stack.h" /* Processes metadata on the client side for HTTP2 transports */ extern const grpc_channel_filter grpc_http_client_filter; diff --git a/src/core/lib/channel/http_server_filter.c b/src/core/lib/channel/http_server_filter.c index 1a2e0c5db3..df99b77ab3 100644 --- a/src/core/lib/channel/http_server_filter.c +++ b/src/core/lib/channel/http_server_filter.c @@ -31,13 +31,13 @@ * */ -#include "src/core/channel/http_server_filter.h" +#include "src/core/lib/channel/http_server_filter.h" #include #include #include -#include "src/core/profiling/timers.h" -#include "src/core/transport/static_metadata.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/transport/static_metadata.h" typedef struct call_data { uint8_t seen_path; diff --git a/src/core/lib/channel/http_server_filter.h b/src/core/lib/channel/http_server_filter.h index 3e6f5782bc..c8cf920ded 100644 --- a/src/core/lib/channel/http_server_filter.h +++ b/src/core/lib/channel/http_server_filter.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_CHANNEL_HTTP_SERVER_FILTER_H #define GRPC_CORE_LIB_CHANNEL_HTTP_SERVER_FILTER_H -#include "src/core/channel/channel_stack.h" +#include "src/core/lib/channel/channel_stack.h" /* Processes metadata on the client side for HTTP2 transports */ extern const grpc_channel_filter grpc_http_server_filter; diff --git a/src/core/lib/channel/subchannel_call_holder.c b/src/core/lib/channel/subchannel_call_holder.c index 9c087dc2a1..6c6d42dd73 100644 --- a/src/core/lib/channel/subchannel_call_holder.c +++ b/src/core/lib/channel/subchannel_call_holder.c @@ -31,11 +31,11 @@ * */ -#include "src/core/channel/subchannel_call_holder.h" +#include "src/core/lib/channel/subchannel_call_holder.h" #include -#include "src/core/profiling/timers.h" +#include "src/core/lib/profiling/timers.h" #define GET_CALL(holder) \ ((grpc_subchannel_call *)(gpr_atm_acq_load(&(holder)->subchannel_call))) diff --git a/src/core/lib/channel/subchannel_call_holder.h b/src/core/lib/channel/subchannel_call_holder.h index 17b4910ac5..882f366792 100644 --- a/src/core/lib/channel/subchannel_call_holder.h +++ b/src/core/lib/channel/subchannel_call_holder.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_CHANNEL_SUBCHANNEL_CALL_HOLDER_H #define GRPC_CORE_LIB_CHANNEL_SUBCHANNEL_CALL_HOLDER_H -#include "src/core/client_config/subchannel.h" +#include "src/core/lib/client_config/subchannel.h" /** Pick a subchannel for grpc_subchannel_call_holder; Return 1 if subchannel is available immediately (in which case on_ready diff --git a/src/core/lib/client_config/client_config.c b/src/core/lib/client_config/client_config.c index c500af25ee..82c8d68099 100644 --- a/src/core/lib/client_config/client_config.c +++ b/src/core/lib/client_config/client_config.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/client_config.h" +#include "src/core/lib/client_config/client_config.h" #include diff --git a/src/core/lib/client_config/client_config.h b/src/core/lib/client_config/client_config.h index c2b5eb7bf3..404ec0d3a5 100644 --- a/src/core/lib/client_config/client_config.h +++ b/src/core/lib/client_config/client_config.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_CLIENT_CONFIG_H #define GRPC_CORE_LIB_CLIENT_CONFIG_CLIENT_CONFIG_H -#include "src/core/client_config/lb_policy.h" +#include "src/core/lib/client_config/lb_policy.h" /** Total configuration for a client. Provided, and updated, by grpc_resolver */ diff --git a/src/core/lib/client_config/connector.c b/src/core/lib/client_config/connector.c index aa34aa7fab..f51d862c6d 100644 --- a/src/core/lib/client_config/connector.c +++ b/src/core/lib/client_config/connector.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/connector.h" +#include "src/core/lib/client_config/connector.h" grpc_connector* grpc_connector_ref(grpc_connector* connector) { connector->vtable->ref(connector); diff --git a/src/core/lib/client_config/connector.h b/src/core/lib/client_config/connector.h index 34a7c26bae..21b925aade 100644 --- a/src/core/lib/client_config/connector.h +++ b/src/core/lib/client_config/connector.h @@ -34,9 +34,9 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_CONNECTOR_H #define GRPC_CORE_LIB_CLIENT_CONFIG_CONNECTOR_H -#include "src/core/channel/channel_stack.h" -#include "src/core/iomgr/sockaddr.h" -#include "src/core/transport/transport.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/iomgr/sockaddr.h" +#include "src/core/lib/transport/transport.h" typedef struct grpc_connector grpc_connector; typedef struct grpc_connector_vtable grpc_connector_vtable; diff --git a/src/core/lib/client_config/default_initial_connect_string.c b/src/core/lib/client_config/default_initial_connect_string.c index 90b4f96327..86eb37de77 100644 --- a/src/core/lib/client_config/default_initial_connect_string.c +++ b/src/core/lib/client_config/default_initial_connect_string.c @@ -32,7 +32,7 @@ */ #include -#include "src/core/iomgr/sockaddr.h" +#include "src/core/lib/iomgr/sockaddr.h" void grpc_set_default_initial_connect_string(struct sockaddr **addr, size_t *addr_len, diff --git a/src/core/lib/client_config/initial_connect_string.c b/src/core/lib/client_config/initial_connect_string.c index d199efebde..95ae728316 100644 --- a/src/core/lib/client_config/initial_connect_string.c +++ b/src/core/lib/client_config/initial_connect_string.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/initial_connect_string.h" +#include "src/core/lib/client_config/initial_connect_string.h" #include diff --git a/src/core/lib/client_config/initial_connect_string.h b/src/core/lib/client_config/initial_connect_string.h index ce8096a28a..eec42fa240 100644 --- a/src/core/lib/client_config/initial_connect_string.h +++ b/src/core/lib/client_config/initial_connect_string.h @@ -35,7 +35,7 @@ #define GRPC_CORE_LIB_CLIENT_CONFIG_INITIAL_CONNECT_STRING_H #include -#include "src/core/iomgr/sockaddr.h" +#include "src/core/lib/iomgr/sockaddr.h" typedef void (*grpc_set_initial_connect_string_func)(struct sockaddr **addr, size_t *addr_len, diff --git a/src/core/lib/client_config/lb_policies/load_balancer_api.c b/src/core/lib/client_config/lb_policies/load_balancer_api.c index a6b5785fe4..4cbed200df 100644 --- a/src/core/lib/client_config/lb_policies/load_balancer_api.c +++ b/src/core/lib/client_config/lb_policies/load_balancer_api.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/lb_policies/load_balancer_api.h" +#include "src/core/lib/client_config/lb_policies/load_balancer_api.h" #include "third_party/nanopb/pb_decode.h" #include "third_party/nanopb/pb_encode.h" diff --git a/src/core/lib/client_config/lb_policies/load_balancer_api.h b/src/core/lib/client_config/lb_policies/load_balancer_api.h index b0ccfaff1f..83299adfa9 100644 --- a/src/core/lib/client_config/lb_policies/load_balancer_api.h +++ b/src/core/lib/client_config/lb_policies/load_balancer_api.h @@ -36,8 +36,8 @@ #include -#include "src/core/client_config/lb_policy_factory.h" -#include "src/core/proto/grpc/lb/v0/load_balancer.pb.h" +#include "src/core/lib/client_config/lb_policy_factory.h" +#include "src/core/lib/proto/grpc/lb/v0/load_balancer.pb.h" #ifdef __cplusplus extern "C" { diff --git a/src/core/lib/client_config/lb_policies/pick_first.c b/src/core/lib/client_config/lb_policies/pick_first.c index 2833f112f4..2e399b73f9 100644 --- a/src/core/lib/client_config/lb_policies/pick_first.c +++ b/src/core/lib/client_config/lb_policies/pick_first.c @@ -31,13 +31,13 @@ * */ -#include "src/core/client_config/lb_policies/pick_first.h" -#include "src/core/client_config/lb_policy_factory.h" +#include "src/core/lib/client_config/lb_policies/pick_first.h" +#include "src/core/lib/client_config/lb_policy_factory.h" #include #include -#include "src/core/transport/connectivity_state.h" +#include "src/core/lib/transport/connectivity_state.h" typedef struct pending_pick { struct pending_pick *next; diff --git a/src/core/lib/client_config/lb_policies/pick_first.h b/src/core/lib/client_config/lb_policies/pick_first.h index 141d354fd2..dba86ea7ad 100644 --- a/src/core/lib/client_config/lb_policies/pick_first.h +++ b/src/core/lib/client_config/lb_policies/pick_first.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICIES_PICK_FIRST_H #define GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICIES_PICK_FIRST_H -#include "src/core/client_config/lb_policy_factory.h" +#include "src/core/lib/client_config/lb_policy_factory.h" /** Returns a load balancing factory for the pick first policy, which picks up * the first subchannel from \a subchannels to succesfully connect */ diff --git a/src/core/lib/client_config/lb_policies/round_robin.c b/src/core/lib/client_config/lb_policies/round_robin.c index 114ece6e4d..c904c5f921 100644 --- a/src/core/lib/client_config/lb_policies/round_robin.c +++ b/src/core/lib/client_config/lb_policies/round_robin.c @@ -31,12 +31,12 @@ * */ -#include "src/core/client_config/lb_policies/round_robin.h" +#include "src/core/lib/client_config/lb_policies/round_robin.h" #include #include -#include "src/core/transport/connectivity_state.h" +#include "src/core/lib/transport/connectivity_state.h" typedef struct round_robin_lb_policy round_robin_lb_policy; diff --git a/src/core/lib/client_config/lb_policies/round_robin.h b/src/core/lib/client_config/lb_policies/round_robin.h index 2f01147897..52db1caa0c 100644 --- a/src/core/lib/client_config/lb_policies/round_robin.h +++ b/src/core/lib/client_config/lb_policies/round_robin.h @@ -34,11 +34,11 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICIES_ROUND_ROBIN_H #define GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICIES_ROUND_ROBIN_H -#include "src/core/client_config/lb_policy.h" +#include "src/core/lib/client_config/lb_policy.h" extern int grpc_lb_round_robin_trace; -#include "src/core/client_config/lb_policy_factory.h" +#include "src/core/lib/client_config/lb_policy_factory.h" /** Returns a load balancing factory for the round robin policy */ grpc_lb_policy_factory *grpc_round_robin_lb_factory_create(); diff --git a/src/core/lib/client_config/lb_policy.c b/src/core/lib/client_config/lb_policy.c index 0d8b007336..ee20ccd76a 100644 --- a/src/core/lib/client_config/lb_policy.c +++ b/src/core/lib/client_config/lb_policy.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/lb_policy.h" +#include "src/core/lib/client_config/lb_policy.h" #define WEAK_REF_BITS 16 diff --git a/src/core/lib/client_config/lb_policy.h b/src/core/lib/client_config/lb_policy.h index 2ccd314d51..58a0a04d85 100644 --- a/src/core/lib/client_config/lb_policy.h +++ b/src/core/lib/client_config/lb_policy.h @@ -34,8 +34,8 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_H #define GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_H -#include "src/core/client_config/subchannel.h" -#include "src/core/transport/connectivity_state.h" +#include "src/core/lib/client_config/subchannel.h" +#include "src/core/lib/transport/connectivity_state.h" /** A load balancing policy: specified by a vtable and a struct (which is expected to be extended to contain some parameters) */ diff --git a/src/core/lib/client_config/lb_policy_factory.c b/src/core/lib/client_config/lb_policy_factory.c index a261922659..2ca6f42f89 100644 --- a/src/core/lib/client_config/lb_policy_factory.c +++ b/src/core/lib/client_config/lb_policy_factory.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/lb_policy_factory.h" +#include "src/core/lib/client_config/lb_policy_factory.h" void grpc_lb_policy_factory_ref(grpc_lb_policy_factory* factory) { factory->vtable->ref(factory); diff --git a/src/core/lib/client_config/lb_policy_factory.h b/src/core/lib/client_config/lb_policy_factory.h index 41eabadefa..36eaf178d9 100644 --- a/src/core/lib/client_config/lb_policy_factory.h +++ b/src/core/lib/client_config/lb_policy_factory.h @@ -34,8 +34,8 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_FACTORY_H #define GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_FACTORY_H -#include "src/core/client_config/lb_policy.h" -#include "src/core/client_config/subchannel.h" +#include "src/core/lib/client_config/lb_policy.h" +#include "src/core/lib/client_config/subchannel.h" typedef struct grpc_lb_policy_factory grpc_lb_policy_factory; typedef struct grpc_lb_policy_factory_vtable grpc_lb_policy_factory_vtable; diff --git a/src/core/lib/client_config/lb_policy_registry.c b/src/core/lib/client_config/lb_policy_registry.c index e836456151..13acfe78cd 100644 --- a/src/core/lib/client_config/lb_policy_registry.c +++ b/src/core/lib/client_config/lb_policy_registry.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/lb_policy_registry.h" +#include "src/core/lib/client_config/lb_policy_registry.h" #include diff --git a/src/core/lib/client_config/lb_policy_registry.h b/src/core/lib/client_config/lb_policy_registry.h index bc82371bbe..c251fd9f08 100644 --- a/src/core/lib/client_config/lb_policy_registry.h +++ b/src/core/lib/client_config/lb_policy_registry.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_REGISTRY_H #define GRPC_CORE_LIB_CLIENT_CONFIG_LB_POLICY_REGISTRY_H -#include "src/core/client_config/lb_policy_factory.h" +#include "src/core/lib/client_config/lb_policy_factory.h" /** Initialize the registry and set \a default_factory as the factory to be * returned when no name is provided in a lookup */ diff --git a/src/core/lib/client_config/resolver.c b/src/core/lib/client_config/resolver.c index 8c677978f8..32f0643adb 100644 --- a/src/core/lib/client_config/resolver.c +++ b/src/core/lib/client_config/resolver.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/resolver.h" +#include "src/core/lib/client_config/resolver.h" void grpc_resolver_init(grpc_resolver *resolver, const grpc_resolver_vtable *vtable) { diff --git a/src/core/lib/client_config/resolver.h b/src/core/lib/client_config/resolver.h index 358f73fa27..1ee879293a 100644 --- a/src/core/lib/client_config/resolver.h +++ b/src/core/lib/client_config/resolver.h @@ -34,9 +34,9 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_H #define GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_H -#include "src/core/client_config/client_config.h" -#include "src/core/client_config/subchannel.h" -#include "src/core/iomgr/iomgr.h" +#include "src/core/lib/client_config/client_config.h" +#include "src/core/lib/client_config/subchannel.h" +#include "src/core/lib/iomgr/iomgr.h" typedef struct grpc_resolver grpc_resolver; typedef struct grpc_resolver_vtable grpc_resolver_vtable; diff --git a/src/core/lib/client_config/resolver_factory.c b/src/core/lib/client_config/resolver_factory.c index 6ee56f0063..0f76c664fa 100644 --- a/src/core/lib/client_config/resolver_factory.c +++ b/src/core/lib/client_config/resolver_factory.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/resolver_factory.h" +#include "src/core/lib/client_config/resolver_factory.h" void grpc_resolver_factory_ref(grpc_resolver_factory* factory) { factory->vtable->ref(factory); diff --git a/src/core/lib/client_config/resolver_factory.h b/src/core/lib/client_config/resolver_factory.h index 3d309c85f8..7765c3c844 100644 --- a/src/core/lib/client_config/resolver_factory.h +++ b/src/core/lib/client_config/resolver_factory.h @@ -34,9 +34,9 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_FACTORY_H #define GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_FACTORY_H -#include "src/core/client_config/resolver.h" -#include "src/core/client_config/subchannel_factory.h" -#include "src/core/client_config/uri_parser.h" +#include "src/core/lib/client_config/resolver.h" +#include "src/core/lib/client_config/subchannel_factory.h" +#include "src/core/lib/client_config/uri_parser.h" typedef struct grpc_resolver_factory grpc_resolver_factory; typedef struct grpc_resolver_factory_vtable grpc_resolver_factory_vtable; diff --git a/src/core/lib/client_config/resolver_registry.c b/src/core/lib/client_config/resolver_registry.c index a38b3d8995..29bd00c284 100644 --- a/src/core/lib/client_config/resolver_registry.c +++ b/src/core/lib/client_config/resolver_registry.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/resolver_registry.h" +#include "src/core/lib/client_config/resolver_registry.h" #include diff --git a/src/core/lib/client_config/resolver_registry.h b/src/core/lib/client_config/resolver_registry.h index 72db20bf00..22289ca6bd 100644 --- a/src/core/lib/client_config/resolver_registry.h +++ b/src/core/lib/client_config/resolver_registry.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_REGISTRY_H #define GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVER_REGISTRY_H -#include "src/core/client_config/resolver_factory.h" +#include "src/core/lib/client_config/resolver_factory.h" void grpc_resolver_registry_init(const char *default_prefix); void grpc_resolver_registry_shutdown(void); diff --git a/src/core/lib/client_config/resolvers/dns_resolver.c b/src/core/lib/client_config/resolvers/dns_resolver.c index 2b2ee97e12..ab445730ad 100644 --- a/src/core/lib/client_config/resolvers/dns_resolver.c +++ b/src/core/lib/client_config/resolvers/dns_resolver.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/resolvers/dns_resolver.h" +#include "src/core/lib/client_config/resolvers/dns_resolver.h" #include @@ -39,11 +39,11 @@ #include #include -#include "src/core/client_config/lb_policy_registry.h" -#include "src/core/iomgr/resolve_address.h" -#include "src/core/iomgr/timer.h" -#include "src/core/support/backoff.h" -#include "src/core/support/string.h" +#include "src/core/lib/client_config/lb_policy_registry.h" +#include "src/core/lib/iomgr/resolve_address.h" +#include "src/core/lib/iomgr/timer.h" +#include "src/core/lib/support/backoff.h" +#include "src/core/lib/support/string.h" #define BACKOFF_MULTIPLIER 1.6 #define BACKOFF_JITTER 0.2 diff --git a/src/core/lib/client_config/resolvers/dns_resolver.h b/src/core/lib/client_config/resolvers/dns_resolver.h index 7dada84278..eb46e41c77 100644 --- a/src/core/lib/client_config/resolvers/dns_resolver.h +++ b/src/core/lib/client_config/resolvers/dns_resolver.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVERS_DNS_RESOLVER_H #define GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVERS_DNS_RESOLVER_H -#include "src/core/client_config/resolver_factory.h" +#include "src/core/lib/client_config/resolver_factory.h" /** Create a dns resolver factory */ grpc_resolver_factory *grpc_dns_resolver_factory_create(void); diff --git a/src/core/lib/client_config/resolvers/sockaddr_resolver.c b/src/core/lib/client_config/resolvers/sockaddr_resolver.c index 3cb7d79b67..66cddc3ed9 100644 --- a/src/core/lib/client_config/resolvers/sockaddr_resolver.c +++ b/src/core/lib/client_config/resolvers/sockaddr_resolver.c @@ -33,7 +33,7 @@ #include -#include "src/core/client_config/resolvers/sockaddr_resolver.h" +#include "src/core/lib/client_config/resolvers/sockaddr_resolver.h" #include #include @@ -42,10 +42,10 @@ #include #include -#include "src/core/client_config/lb_policy_registry.h" -#include "src/core/iomgr/resolve_address.h" -#include "src/core/iomgr/unix_sockets_posix.h" -#include "src/core/support/string.h" +#include "src/core/lib/client_config/lb_policy_registry.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" typedef struct { /** base class: must be first */ diff --git a/src/core/lib/client_config/resolvers/sockaddr_resolver.h b/src/core/lib/client_config/resolvers/sockaddr_resolver.h index 3bbcf1dd81..45c55bd160 100644 --- a/src/core/lib/client_config/resolvers/sockaddr_resolver.h +++ b/src/core/lib/client_config/resolvers/sockaddr_resolver.h @@ -36,7 +36,7 @@ #include -#include "src/core/client_config/resolver_factory.h" +#include "src/core/lib/client_config/resolver_factory.h" grpc_resolver_factory *grpc_ipv4_resolver_factory_create(void); diff --git a/src/core/lib/client_config/resolvers/zookeeper_resolver.c b/src/core/lib/client_config/resolvers/zookeeper_resolver.c index e0e18792a2..3bb0bbdf5c 100644 --- a/src/core/lib/client_config/resolvers/zookeeper_resolver.c +++ b/src/core/lib/client_config/resolvers/zookeeper_resolver.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/resolvers/zookeeper_resolver.h" +#include "src/core/lib/client_config/resolvers/zookeeper_resolver.h" #include @@ -41,12 +41,12 @@ #include #include -#include "src/core/client_config/lb_policy_registry.h" -#include "src/core/client_config/resolver_registry.h" -#include "src/core/iomgr/resolve_address.h" -#include "src/core/json/json.h" -#include "src/core/support/string.h" -#include "src/core/surface/api_trace.h" +#include "src/core/lib/client_config/lb_policy_registry.h" +#include "src/core/lib/client_config/resolver_registry.h" +#include "src/core/lib/iomgr/resolve_address.h" +#include "src/core/lib/json/json.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/api_trace.h" /** Zookeeper session expiration time in milliseconds */ #define GRPC_ZOOKEEPER_SESSION_TIMEOUT 15000 diff --git a/src/core/lib/client_config/resolvers/zookeeper_resolver.h b/src/core/lib/client_config/resolvers/zookeeper_resolver.h index 603097e5f8..7ee7604360 100644 --- a/src/core/lib/client_config/resolvers/zookeeper_resolver.h +++ b/src/core/lib/client_config/resolvers/zookeeper_resolver.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVERS_ZOOKEEPER_RESOLVER_H #define GRPC_CORE_LIB_CLIENT_CONFIG_RESOLVERS_ZOOKEEPER_RESOLVER_H -#include "src/core/client_config/resolver_factory.h" +#include "src/core/lib/client_config/resolver_factory.h" /** Create a zookeeper resolver factory */ grpc_resolver_factory *grpc_zookeeper_resolver_factory_create(void); diff --git a/src/core/lib/client_config/subchannel.c b/src/core/lib/client_config/subchannel.c index c5cd504929..41242f0dd7 100644 --- a/src/core/lib/client_config/subchannel.c +++ b/src/core/lib/client_config/subchannel.c @@ -31,24 +31,24 @@ * */ -#include "src/core/client_config/subchannel.h" +#include "src/core/lib/client_config/subchannel.h" #include #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/channel/client_channel.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/client_config/initial_connect_string.h" -#include "src/core/client_config/subchannel_index.h" -#include "src/core/iomgr/timer.h" -#include "src/core/profiling/timers.h" -#include "src/core/support/backoff.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/channel_init.h" -#include "src/core/transport/connectivity_state.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/client_config/initial_connect_string.h" +#include "src/core/lib/client_config/subchannel_index.h" +#include "src/core/lib/iomgr/timer.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/support/backoff.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/channel_init.h" +#include "src/core/lib/transport/connectivity_state.h" #define INTERNAL_REF_BITS 16 #define STRONG_REF_MASK (~(gpr_atm)((1 << INTERNAL_REF_BITS) - 1)) diff --git a/src/core/lib/client_config/subchannel.h b/src/core/lib/client_config/subchannel.h index a8fcbe7b0e..b4f545be52 100644 --- a/src/core/lib/client_config/subchannel.h +++ b/src/core/lib/client_config/subchannel.h @@ -34,9 +34,9 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_H #define GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_H -#include "src/core/channel/channel_stack.h" -#include "src/core/client_config/connector.h" -#include "src/core/transport/connectivity_state.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/client_config/connector.h" +#include "src/core/lib/transport/connectivity_state.h" /** A (sub-)channel that knows how to connect to exactly one target address. Provides a target for load balancing. */ diff --git a/src/core/lib/client_config/subchannel_factory.c b/src/core/lib/client_config/subchannel_factory.c index 8caeaf11bf..727a48a6c8 100644 --- a/src/core/lib/client_config/subchannel_factory.c +++ b/src/core/lib/client_config/subchannel_factory.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/subchannel_factory.h" +#include "src/core/lib/client_config/subchannel_factory.h" void grpc_subchannel_factory_ref(grpc_subchannel_factory* factory) { factory->vtable->ref(factory); diff --git a/src/core/lib/client_config/subchannel_factory.h b/src/core/lib/client_config/subchannel_factory.h index 1017b13fcd..3ba2f860fe 100644 --- a/src/core/lib/client_config/subchannel_factory.h +++ b/src/core/lib/client_config/subchannel_factory.h @@ -34,8 +34,8 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_FACTORY_H #define GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_FACTORY_H -#include "src/core/channel/channel_stack.h" -#include "src/core/client_config/subchannel.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/client_config/subchannel.h" typedef struct grpc_subchannel_factory grpc_subchannel_factory; typedef struct grpc_subchannel_factory_vtable grpc_subchannel_factory_vtable; diff --git a/src/core/lib/client_config/subchannel_index.c b/src/core/lib/client_config/subchannel_index.c index 24cc76cf22..2c545002a2 100644 --- a/src/core/lib/client_config/subchannel_index.c +++ b/src/core/lib/client_config/subchannel_index.c @@ -31,7 +31,7 @@ // // -#include "src/core/client_config/subchannel_index.h" +#include "src/core/lib/client_config/subchannel_index.h" #include #include @@ -40,7 +40,7 @@ #include #include -#include "src/core/channel/channel_args.h" +#include "src/core/lib/channel/channel_args.h" // a map of subchannel_key --> subchannel, used for detecting connections // to the same destination in order to share them diff --git a/src/core/lib/client_config/subchannel_index.h b/src/core/lib/client_config/subchannel_index.h index f5627dfaf7..bc5f03beb4 100644 --- a/src/core/lib/client_config/subchannel_index.h +++ b/src/core/lib/client_config/subchannel_index.h @@ -34,8 +34,8 @@ #ifndef GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_INDEX_H #define GRPC_CORE_LIB_CLIENT_CONFIG_SUBCHANNEL_INDEX_H -#include "src/core/client_config/connector.h" -#include "src/core/client_config/subchannel.h" +#include "src/core/lib/client_config/connector.h" +#include "src/core/lib/client_config/subchannel.h" /** \file Provides an index of active subchannels so that they can be shared amongst channels */ diff --git a/src/core/lib/client_config/uri_parser.c b/src/core/lib/client_config/uri_parser.c index c1b64778b1..d3228dec5f 100644 --- a/src/core/lib/client_config/uri_parser.c +++ b/src/core/lib/client_config/uri_parser.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/uri_parser.h" +#include "src/core/lib/client_config/uri_parser.h" #include diff --git a/src/core/lib/compression/algorithm_metadata.h b/src/core/lib/compression/algorithm_metadata.h index 6ebde1e8fd..47f33abdc7 100644 --- a/src/core/lib/compression/algorithm_metadata.h +++ b/src/core/lib/compression/algorithm_metadata.h @@ -35,7 +35,7 @@ #define GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_H #include -#include "src/core/transport/metadata.h" +#include "src/core/lib/transport/metadata.h" /** Return compression algorithm based metadata value */ grpc_mdstr *grpc_compression_algorithm_mdstr( diff --git a/src/core/lib/compression/compression_algorithm.c b/src/core/lib/compression/compression_algorithm.c index 2810a38b68..f781b45042 100644 --- a/src/core/lib/compression/compression_algorithm.c +++ b/src/core/lib/compression/compression_algorithm.c @@ -37,9 +37,9 @@ #include #include -#include "src/core/compression/algorithm_metadata.h" -#include "src/core/surface/api_trace.h" -#include "src/core/transport/static_metadata.h" +#include "src/core/lib/compression/algorithm_metadata.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/transport/static_metadata.h" int grpc_compression_algorithm_parse(const char *name, size_t name_length, grpc_compression_algorithm *algorithm) { diff --git a/src/core/lib/compression/message_compress.c b/src/core/lib/compression/message_compress.c index c3a21ec19f..b4b6a2d75e 100644 --- a/src/core/lib/compression/message_compress.c +++ b/src/core/lib/compression/message_compress.c @@ -31,7 +31,7 @@ * */ -#include "src/core/compression/message_compress.h" +#include "src/core/lib/compression/message_compress.h" #include diff --git a/src/core/lib/debug/trace.c b/src/core/lib/debug/trace.c index 42150b1bc3..786dd9324f 100644 --- a/src/core/lib/debug/trace.c +++ b/src/core/lib/debug/trace.c @@ -31,14 +31,14 @@ * */ -#include "src/core/debug/trace.h" +#include "src/core/lib/debug/trace.h" #include #include #include #include -#include "src/core/support/env.h" +#include "src/core/lib/support/env.h" typedef struct tracer { const char *name; diff --git a/src/core/lib/http/format_request.c b/src/core/lib/http/format_request.c index ac9bb8aeb8..95b3918646 100644 --- a/src/core/lib/http/format_request.c +++ b/src/core/lib/http/format_request.c @@ -31,7 +31,7 @@ * */ -#include "src/core/http/format_request.h" +#include "src/core/lib/http/format_request.h" #include #include @@ -41,7 +41,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" static void fill_common_header(const grpc_httpcli_request *request, gpr_strvec *buf) { diff --git a/src/core/lib/http/format_request.h b/src/core/lib/http/format_request.h index eb8e3267b6..2e933d804b 100644 --- a/src/core/lib/http/format_request.h +++ b/src/core/lib/http/format_request.h @@ -35,7 +35,7 @@ #define GRPC_CORE_LIB_HTTP_FORMAT_REQUEST_H #include -#include "src/core/http/httpcli.h" +#include "src/core/lib/http/httpcli.h" gpr_slice grpc_httpcli_format_get_request(const grpc_httpcli_request *request); gpr_slice grpc_httpcli_format_post_request(const grpc_httpcli_request *request, diff --git a/src/core/lib/http/httpcli.c b/src/core/lib/http/httpcli.c index 1c0d3336ea..aab28ad8b6 100644 --- a/src/core/lib/http/httpcli.c +++ b/src/core/lib/http/httpcli.c @@ -31,8 +31,8 @@ * */ -#include "src/core/http/httpcli.h" -#include "src/core/iomgr/sockaddr.h" +#include "src/core/lib/http/httpcli.h" +#include "src/core/lib/iomgr/sockaddr.h" #include @@ -40,13 +40,13 @@ #include #include -#include "src/core/http/format_request.h" -#include "src/core/http/parser.h" -#include "src/core/iomgr/endpoint.h" -#include "src/core/iomgr/iomgr_internal.h" -#include "src/core/iomgr/resolve_address.h" -#include "src/core/iomgr/tcp_client.h" -#include "src/core/support/string.h" +#include "src/core/lib/http/format_request.h" +#include "src/core/lib/http/parser.h" +#include "src/core/lib/iomgr/endpoint.h" +#include "src/core/lib/iomgr/iomgr_internal.h" +#include "src/core/lib/iomgr/resolve_address.h" +#include "src/core/lib/iomgr/tcp_client.h" +#include "src/core/lib/support/string.h" typedef struct { gpr_slice request_text; diff --git a/src/core/lib/http/httpcli.h b/src/core/lib/http/httpcli.h index f28d6d7481..b8d54a8586 100644 --- a/src/core/lib/http/httpcli.h +++ b/src/core/lib/http/httpcli.h @@ -38,10 +38,10 @@ #include -#include "src/core/http/parser.h" -#include "src/core/iomgr/endpoint.h" -#include "src/core/iomgr/iomgr_internal.h" -#include "src/core/iomgr/pollset_set.h" +#include "src/core/lib/http/parser.h" +#include "src/core/lib/iomgr/endpoint.h" +#include "src/core/lib/iomgr/iomgr_internal.h" +#include "src/core/lib/iomgr/pollset_set.h" /* User agent this library reports */ #define GRPC_HTTPCLI_USER_AGENT "grpc-httpcli/0.0" diff --git a/src/core/lib/http/httpcli_security_connector.c b/src/core/lib/http/httpcli_security_connector.c index a1a32f7558..6f1630ac1f 100644 --- a/src/core/lib/http/httpcli_security_connector.c +++ b/src/core/lib/http/httpcli_security_connector.c @@ -31,16 +31,16 @@ * */ -#include "src/core/http/httpcli.h" +#include "src/core/lib/http/httpcli.h" #include #include #include #include -#include "src/core/security/handshake.h" -#include "src/core/support/string.h" -#include "src/core/tsi/ssl_transport_security.h" +#include "src/core/lib/security/handshake.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/tsi/ssl_transport_security.h" typedef struct { grpc_channel_security_connector base; diff --git a/src/core/lib/http/parser.c b/src/core/lib/http/parser.c index ebec8a5157..5d4e304615 100644 --- a/src/core/lib/http/parser.c +++ b/src/core/lib/http/parser.c @@ -31,7 +31,7 @@ * */ -#include "src/core/http/parser.h" +#include "src/core/lib/http/parser.h" #include diff --git a/src/core/lib/iomgr/closure.c b/src/core/lib/iomgr/closure.c index 3a96f7385f..724ebc284a 100644 --- a/src/core/lib/iomgr/closure.c +++ b/src/core/lib/iomgr/closure.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/closure.h" +#include "src/core/lib/iomgr/closure.h" #include diff --git a/src/core/lib/iomgr/endpoint.c b/src/core/lib/iomgr/endpoint.c index f1bdd0fc6c..576b5a6e5c 100644 --- a/src/core/lib/iomgr/endpoint.c +++ b/src/core/lib/iomgr/endpoint.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/endpoint.h" +#include "src/core/lib/iomgr/endpoint.h" void grpc_endpoint_read(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep, gpr_slice_buffer* slices, grpc_closure* cb) { diff --git a/src/core/lib/iomgr/endpoint.h b/src/core/lib/iomgr/endpoint.h index 740ec50c6a..918e705fbd 100644 --- a/src/core/lib/iomgr/endpoint.h +++ b/src/core/lib/iomgr/endpoint.h @@ -37,8 +37,8 @@ #include #include #include -#include "src/core/iomgr/pollset.h" -#include "src/core/iomgr/pollset_set.h" +#include "src/core/lib/iomgr/pollset.h" +#include "src/core/lib/iomgr/pollset_set.h" /* An endpoint caps a streaming channel between two communicating processes. Examples may be: a tcp socket, , or some shared memory. */ diff --git a/src/core/lib/iomgr/endpoint_pair.h b/src/core/lib/iomgr/endpoint_pair.h index 39af04c9df..bef8bb3518 100644 --- a/src/core/lib/iomgr/endpoint_pair.h +++ b/src/core/lib/iomgr/endpoint_pair.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_IOMGR_ENDPOINT_PAIR_H #define GRPC_CORE_LIB_IOMGR_ENDPOINT_PAIR_H -#include "src/core/iomgr/endpoint.h" +#include "src/core/lib/iomgr/endpoint.h" typedef struct { grpc_endpoint *client; diff --git a/src/core/lib/iomgr/endpoint_pair_posix.c b/src/core/lib/iomgr/endpoint_pair_posix.c index 66d19a486c..e0ce47c773 100644 --- a/src/core/lib/iomgr/endpoint_pair_posix.c +++ b/src/core/lib/iomgr/endpoint_pair_posix.c @@ -35,9 +35,9 @@ #ifdef GPR_POSIX_SOCKET -#include "src/core/iomgr/endpoint_pair.h" -#include "src/core/iomgr/socket_utils_posix.h" -#include "src/core/iomgr/unix_sockets_posix.h" +#include "src/core/lib/iomgr/endpoint_pair.h" +#include "src/core/lib/iomgr/socket_utils_posix.h" +#include "src/core/lib/iomgr/unix_sockets_posix.h" #include #include @@ -48,8 +48,8 @@ #include #include #include -#include "src/core/iomgr/tcp_posix.h" -#include "src/core/support/string.h" +#include "src/core/lib/iomgr/tcp_posix.h" +#include "src/core/lib/support/string.h" static void create_sockets(int sv[2]) { int flags; diff --git a/src/core/lib/iomgr/endpoint_pair_windows.c b/src/core/lib/iomgr/endpoint_pair_windows.c index 2024f58143..cba18db81f 100644 --- a/src/core/lib/iomgr/endpoint_pair_windows.c +++ b/src/core/lib/iomgr/endpoint_pair_windows.c @@ -34,16 +34,16 @@ #include #ifdef GPR_WINSOCK_SOCKET -#include "src/core/iomgr/endpoint_pair.h" -#include "src/core/iomgr/sockaddr_utils.h" +#include "src/core/lib/iomgr/endpoint_pair.h" +#include "src/core/lib/iomgr/sockaddr_utils.h" #include #include #include #include -#include "src/core/iomgr/socket_windows.h" -#include "src/core/iomgr/tcp_windows.h" +#include "src/core/lib/iomgr/socket_windows.h" +#include "src/core/lib/iomgr/tcp_windows.h" static void create_sockets(SOCKET sv[2]) { SOCKET svr_sock = INVALID_SOCKET; diff --git a/src/core/lib/iomgr/exec_ctx.c b/src/core/lib/iomgr/exec_ctx.c index 893fe4515c..1ed6da623a 100644 --- a/src/core/lib/iomgr/exec_ctx.c +++ b/src/core/lib/iomgr/exec_ctx.c @@ -31,13 +31,13 @@ * */ -#include "src/core/iomgr/exec_ctx.h" +#include "src/core/lib/iomgr/exec_ctx.h" #include #include #include -#include "src/core/profiling/timers.h" +#include "src/core/lib/profiling/timers.h" #ifndef GRPC_EXECUTION_CONTEXT_SANITIZER bool grpc_exec_ctx_flush(grpc_exec_ctx *exec_ctx) { diff --git a/src/core/lib/iomgr/exec_ctx.h b/src/core/lib/iomgr/exec_ctx.h index a6551cf1d4..e62ea2dedf 100644 --- a/src/core/lib/iomgr/exec_ctx.h +++ b/src/core/lib/iomgr/exec_ctx.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_IOMGR_EXEC_CTX_H #define GRPC_CORE_LIB_IOMGR_EXEC_CTX_H -#include "src/core/iomgr/closure.h" +#include "src/core/lib/iomgr/closure.h" /* #define GRPC_EXECUTION_CONTEXT_SANITIZER 1 */ diff --git a/src/core/lib/iomgr/executor.c b/src/core/lib/iomgr/executor.c index f22d8f30ac..42a9db3cbb 100644 --- a/src/core/lib/iomgr/executor.c +++ b/src/core/lib/iomgr/executor.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/executor.h" +#include "src/core/lib/iomgr/executor.h" #include @@ -39,7 +39,7 @@ #include #include #include -#include "src/core/iomgr/exec_ctx.h" +#include "src/core/lib/iomgr/exec_ctx.h" typedef struct grpc_executor_data { int busy; /**< is the thread currently running? */ diff --git a/src/core/lib/iomgr/executor.h b/src/core/lib/iomgr/executor.h index 7197c3f24a..f1871416a0 100644 --- a/src/core/lib/iomgr/executor.h +++ b/src/core/lib/iomgr/executor.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_IOMGR_EXECUTOR_H #define GRPC_CORE_LIB_IOMGR_EXECUTOR_H -#include "src/core/iomgr/closure.h" +#include "src/core/lib/iomgr/closure.h" /** Initialize the global executor. * diff --git a/src/core/lib/iomgr/fd_posix.c b/src/core/lib/iomgr/fd_posix.c index b4d038a3a1..72c924bdcb 100644 --- a/src/core/lib/iomgr/fd_posix.c +++ b/src/core/lib/iomgr/fd_posix.c @@ -35,7 +35,7 @@ #ifdef GPR_POSIX_SOCKET -#include "src/core/iomgr/fd_posix.h" +#include "src/core/lib/iomgr/fd_posix.h" #include #include @@ -46,7 +46,7 @@ #include #include -#include "src/core/iomgr/pollset_posix.h" +#include "src/core/lib/iomgr/pollset_posix.h" #define CLOSURE_NOT_READY ((grpc_closure *)0) #define CLOSURE_READY ((grpc_closure *)1) diff --git a/src/core/lib/iomgr/fd_posix.h b/src/core/lib/iomgr/fd_posix.h index a14c39f722..69d09ef5e3 100644 --- a/src/core/lib/iomgr/fd_posix.h +++ b/src/core/lib/iomgr/fd_posix.h @@ -37,8 +37,8 @@ #include #include #include -#include "src/core/iomgr/iomgr_internal.h" -#include "src/core/iomgr/pollset.h" +#include "src/core/lib/iomgr/iomgr_internal.h" +#include "src/core/lib/iomgr/pollset.h" typedef struct grpc_fd grpc_fd; diff --git a/src/core/lib/iomgr/iocp_windows.c b/src/core/lib/iomgr/iocp_windows.c index 37e277dcc1..682a32c0da 100644 --- a/src/core/lib/iomgr/iocp_windows.c +++ b/src/core/lib/iomgr/iocp_windows.c @@ -42,10 +42,10 @@ #include #include -#include "src/core/iomgr/iocp_windows.h" -#include "src/core/iomgr/iomgr_internal.h" -#include "src/core/iomgr/socket_windows.h" -#include "src/core/iomgr/timer.h" +#include "src/core/lib/iomgr/iocp_windows.h" +#include "src/core/lib/iomgr/iomgr_internal.h" +#include "src/core/lib/iomgr/socket_windows.h" +#include "src/core/lib/iomgr/timer.h" static ULONG g_iocp_kick_token; static OVERLAPPED g_iocp_custom_overlap; diff --git a/src/core/lib/iomgr/iocp_windows.h b/src/core/lib/iomgr/iocp_windows.h index 9444dd4fce..856c837fb4 100644 --- a/src/core/lib/iomgr/iocp_windows.h +++ b/src/core/lib/iomgr/iocp_windows.h @@ -36,7 +36,7 @@ #include -#include "src/core/iomgr/socket_windows.h" +#include "src/core/lib/iomgr/socket_windows.h" typedef enum { GRPC_IOCP_WORK_WORK, diff --git a/src/core/lib/iomgr/iomgr.c b/src/core/lib/iomgr/iomgr.c index 3ab4430668..bb544c8280 100644 --- a/src/core/lib/iomgr/iomgr.c +++ b/src/core/lib/iomgr/iomgr.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/iomgr.h" +#include "src/core/lib/iomgr/iomgr.h" #include #include @@ -43,11 +43,11 @@ #include #include -#include "src/core/iomgr/exec_ctx.h" -#include "src/core/iomgr/iomgr_internal.h" -#include "src/core/iomgr/timer.h" -#include "src/core/support/env.h" -#include "src/core/support/string.h" +#include "src/core/lib/iomgr/exec_ctx.h" +#include "src/core/lib/iomgr/iomgr_internal.h" +#include "src/core/lib/iomgr/timer.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/support/string.h" static gpr_mu g_mu; static gpr_cv g_rcv; diff --git a/src/core/lib/iomgr/iomgr_internal.h b/src/core/lib/iomgr/iomgr_internal.h index 2aeee7f6ae..0963630c61 100644 --- a/src/core/lib/iomgr/iomgr_internal.h +++ b/src/core/lib/iomgr/iomgr_internal.h @@ -37,7 +37,7 @@ #include #include -#include "src/core/iomgr/iomgr.h" +#include "src/core/lib/iomgr/iomgr.h" typedef struct grpc_iomgr_object { char *name; diff --git a/src/core/lib/iomgr/iomgr_posix.c b/src/core/lib/iomgr/iomgr_posix.c index 2f7f34746b..e4990f7bce 100644 --- a/src/core/lib/iomgr/iomgr_posix.c +++ b/src/core/lib/iomgr/iomgr_posix.c @@ -35,10 +35,10 @@ #ifdef GPR_POSIX_SOCKET -#include "src/core/debug/trace.h" -#include "src/core/iomgr/fd_posix.h" -#include "src/core/iomgr/iomgr_posix.h" -#include "src/core/iomgr/tcp_posix.h" +#include "src/core/lib/debug/trace.h" +#include "src/core/lib/iomgr/fd_posix.h" +#include "src/core/lib/iomgr/iomgr_posix.h" +#include "src/core/lib/iomgr/tcp_posix.h" void grpc_iomgr_platform_init(void) { grpc_fd_global_init(); diff --git a/src/core/lib/iomgr/iomgr_posix.h b/src/core/lib/iomgr/iomgr_posix.h index 83fb082665..6a8996e403 100644 --- a/src/core/lib/iomgr/iomgr_posix.h +++ b/src/core/lib/iomgr/iomgr_posix.h @@ -34,6 +34,6 @@ #ifndef GRPC_CORE_LIB_IOMGR_IOMGR_POSIX_H #define GRPC_CORE_LIB_IOMGR_IOMGR_POSIX_H -#include "src/core/iomgr/iomgr_internal.h" +#include "src/core/lib/iomgr/iomgr_internal.h" #endif /* GRPC_CORE_LIB_IOMGR_IOMGR_POSIX_H */ diff --git a/src/core/lib/iomgr/iomgr_windows.c b/src/core/lib/iomgr/iomgr_windows.c index 2d104130f7..af7e616394 100644 --- a/src/core/lib/iomgr/iomgr_windows.c +++ b/src/core/lib/iomgr/iomgr_windows.c @@ -35,13 +35,13 @@ #ifdef GPR_WINSOCK_SOCKET -#include "src/core/iomgr/sockaddr_win32.h" +#include "src/core/lib/iomgr/sockaddr_win32.h" #include -#include "src/core/iomgr/iocp_windows.h" -#include "src/core/iomgr/iomgr.h" -#include "src/core/iomgr/socket_windows.h" +#include "src/core/lib/iomgr/iocp_windows.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/iomgr/socket_windows.h" /* Windows' io manager is going to be fully designed using IO completion ports. All of what we're doing here is basically make sure that diff --git a/src/core/lib/iomgr/pollset.h b/src/core/lib/iomgr/pollset.h index db13f8ac69..6156124862 100644 --- a/src/core/lib/iomgr/pollset.h +++ b/src/core/lib/iomgr/pollset.h @@ -38,7 +38,7 @@ #include #include -#include "src/core/iomgr/exec_ctx.h" +#include "src/core/lib/iomgr/exec_ctx.h" #define GRPC_POLLSET_KICK_BROADCAST ((grpc_pollset_worker *)1) diff --git a/src/core/lib/iomgr/pollset_multipoller_with_epoll.c b/src/core/lib/iomgr/pollset_multipoller_with_epoll.c index 2e0f27fab8..fa1b0d2d84 100644 --- a/src/core/lib/iomgr/pollset_multipoller_with_epoll.c +++ b/src/core/lib/iomgr/pollset_multipoller_with_epoll.c @@ -44,10 +44,10 @@ #include #include #include -#include "src/core/iomgr/fd_posix.h" -#include "src/core/iomgr/pollset_posix.h" -#include "src/core/profiling/timers.h" -#include "src/core/support/block_annotate.h" +#include "src/core/lib/iomgr/fd_posix.h" +#include "src/core/lib/iomgr/pollset_posix.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/support/block_annotate.h" struct epoll_fd_list { int *epoll_fds; diff --git a/src/core/lib/iomgr/pollset_multipoller_with_poll_posix.c b/src/core/lib/iomgr/pollset_multipoller_with_poll_posix.c index 92d6fb7241..9b33f6dbb2 100644 --- a/src/core/lib/iomgr/pollset_multipoller_with_poll_posix.c +++ b/src/core/lib/iomgr/pollset_multipoller_with_poll_posix.c @@ -35,7 +35,7 @@ #ifdef GPR_POSIX_SOCKET -#include "src/core/iomgr/pollset_posix.h" +#include "src/core/lib/iomgr/pollset_posix.h" #include #include @@ -46,10 +46,10 @@ #include #include -#include "src/core/iomgr/fd_posix.h" -#include "src/core/iomgr/iomgr_internal.h" -#include "src/core/iomgr/pollset_posix.h" -#include "src/core/support/block_annotate.h" +#include "src/core/lib/iomgr/fd_posix.h" +#include "src/core/lib/iomgr/iomgr_internal.h" +#include "src/core/lib/iomgr/pollset_posix.h" +#include "src/core/lib/support/block_annotate.h" typedef struct { /* all polled fds */ diff --git a/src/core/lib/iomgr/pollset_posix.c b/src/core/lib/iomgr/pollset_posix.c index e895a77884..259c7bc194 100644 --- a/src/core/lib/iomgr/pollset_posix.c +++ b/src/core/lib/iomgr/pollset_posix.c @@ -35,7 +35,7 @@ #ifdef GPR_POSIX_SOCKET -#include "src/core/iomgr/pollset_posix.h" +#include "src/core/lib/iomgr/pollset_posix.h" #include #include @@ -47,11 +47,11 @@ #include #include #include -#include "src/core/iomgr/fd_posix.h" -#include "src/core/iomgr/iomgr_internal.h" -#include "src/core/iomgr/socket_utils_posix.h" -#include "src/core/profiling/timers.h" -#include "src/core/support/block_annotate.h" +#include "src/core/lib/iomgr/fd_posix.h" +#include "src/core/lib/iomgr/iomgr_internal.h" +#include "src/core/lib/iomgr/socket_utils_posix.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/support/block_annotate.h" GPR_TLS_DECL(g_current_thread_poller); GPR_TLS_DECL(g_current_thread_worker); diff --git a/src/core/lib/iomgr/pollset_posix.h b/src/core/lib/iomgr/pollset_posix.h index c4d1977a0b..7d8e9fc279 100644 --- a/src/core/lib/iomgr/pollset_posix.h +++ b/src/core/lib/iomgr/pollset_posix.h @@ -38,10 +38,10 @@ #include -#include "src/core/iomgr/exec_ctx.h" -#include "src/core/iomgr/iomgr.h" -#include "src/core/iomgr/pollset.h" -#include "src/core/iomgr/wakeup_fd_posix.h" +#include "src/core/lib/iomgr/exec_ctx.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/iomgr/pollset.h" +#include "src/core/lib/iomgr/wakeup_fd_posix.h" typedef struct grpc_pollset_vtable grpc_pollset_vtable; diff --git a/src/core/lib/iomgr/pollset_set.h b/src/core/lib/iomgr/pollset_set.h index 7af72a0297..fb29d692d7 100644 --- a/src/core/lib/iomgr/pollset_set.h +++ b/src/core/lib/iomgr/pollset_set.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_IOMGR_POLLSET_SET_H #define GRPC_CORE_LIB_IOMGR_POLLSET_SET_H -#include "src/core/iomgr/pollset.h" +#include "src/core/lib/iomgr/pollset.h" /* A grpc_pollset_set is a set of pollsets that are interested in an action. Adding a pollset to a pollset_set automatically adds any diff --git a/src/core/lib/iomgr/pollset_set_posix.c b/src/core/lib/iomgr/pollset_set_posix.c index 9dc9aff4a8..d6142f9b6b 100644 --- a/src/core/lib/iomgr/pollset_set_posix.c +++ b/src/core/lib/iomgr/pollset_set_posix.c @@ -41,8 +41,8 @@ #include #include -#include "src/core/iomgr/pollset_posix.h" -#include "src/core/iomgr/pollset_set_posix.h" +#include "src/core/lib/iomgr/pollset_posix.h" +#include "src/core/lib/iomgr/pollset_set_posix.h" struct grpc_pollset_set { gpr_mu mu; diff --git a/src/core/lib/iomgr/pollset_set_posix.h b/src/core/lib/iomgr/pollset_set_posix.h index db997e1bf0..4e6b063c6f 100644 --- a/src/core/lib/iomgr/pollset_set_posix.h +++ b/src/core/lib/iomgr/pollset_set_posix.h @@ -34,8 +34,8 @@ #ifndef GRPC_CORE_LIB_IOMGR_POLLSET_SET_POSIX_H #define GRPC_CORE_LIB_IOMGR_POLLSET_SET_POSIX_H -#include "src/core/iomgr/fd_posix.h" -#include "src/core/iomgr/pollset_set.h" +#include "src/core/lib/iomgr/fd_posix.h" +#include "src/core/lib/iomgr/pollset_set.h" void grpc_pollset_set_add_fd(grpc_exec_ctx *exec_ctx, grpc_pollset_set *pollset_set, grpc_fd *fd); diff --git a/src/core/lib/iomgr/pollset_set_windows.c b/src/core/lib/iomgr/pollset_set_windows.c index 3b8eca28e6..0b14e446ae 100644 --- a/src/core/lib/iomgr/pollset_set_windows.c +++ b/src/core/lib/iomgr/pollset_set_windows.c @@ -35,7 +35,7 @@ #ifdef GPR_WINSOCK_SOCKET -#include "src/core/iomgr/pollset_set_windows.h" +#include "src/core/lib/iomgr/pollset_set_windows.h" grpc_pollset_set* grpc_pollset_set_create(pollset_set) { return NULL; } diff --git a/src/core/lib/iomgr/pollset_set_windows.h b/src/core/lib/iomgr/pollset_set_windows.h index f0b37f8d21..7c2cea23de 100644 --- a/src/core/lib/iomgr/pollset_set_windows.h +++ b/src/core/lib/iomgr/pollset_set_windows.h @@ -34,6 +34,6 @@ #ifndef GRPC_CORE_LIB_IOMGR_POLLSET_SET_WINDOWS_H #define GRPC_CORE_LIB_IOMGR_POLLSET_SET_WINDOWS_H -#include "src/core/iomgr/pollset_set.h" +#include "src/core/lib/iomgr/pollset_set.h" #endif /* GRPC_CORE_LIB_IOMGR_POLLSET_SET_WINDOWS_H */ diff --git a/src/core/lib/iomgr/pollset_windows.c b/src/core/lib/iomgr/pollset_windows.c index 1a99224c80..6b339127a8 100644 --- a/src/core/lib/iomgr/pollset_windows.c +++ b/src/core/lib/iomgr/pollset_windows.c @@ -38,10 +38,10 @@ #include #include -#include "src/core/iomgr/iocp_windows.h" -#include "src/core/iomgr/iomgr_internal.h" -#include "src/core/iomgr/pollset.h" -#include "src/core/iomgr/pollset_windows.h" +#include "src/core/lib/iomgr/iocp_windows.h" +#include "src/core/lib/iomgr/iomgr_internal.h" +#include "src/core/lib/iomgr/pollset.h" +#include "src/core/lib/iomgr/pollset_windows.h" gpr_mu grpc_polling_mu; static grpc_pollset_worker *g_active_poller; diff --git a/src/core/lib/iomgr/pollset_windows.h b/src/core/lib/iomgr/pollset_windows.h index ff8e0a7b46..fa9553ffea 100644 --- a/src/core/lib/iomgr/pollset_windows.h +++ b/src/core/lib/iomgr/pollset_windows.h @@ -36,7 +36,7 @@ #include -#include "src/core/iomgr/socket_windows.h" +#include "src/core/lib/iomgr/socket_windows.h" /* There isn't really any such thing as a pollset under Windows, due to the nature of the IO completion ports. A Windows "pollset" is merely a mutex diff --git a/src/core/lib/iomgr/resolve_address.h b/src/core/lib/iomgr/resolve_address.h index d3da7cc33e..f748288685 100644 --- a/src/core/lib/iomgr/resolve_address.h +++ b/src/core/lib/iomgr/resolve_address.h @@ -35,8 +35,8 @@ #define GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_H #include -#include "src/core/iomgr/exec_ctx.h" -#include "src/core/iomgr/iomgr.h" +#include "src/core/lib/iomgr/exec_ctx.h" +#include "src/core/lib/iomgr/iomgr.h" #define GRPC_MAX_SOCKADDR_SIZE 128 diff --git a/src/core/lib/iomgr/resolve_address_posix.c b/src/core/lib/iomgr/resolve_address_posix.c index 26b3aa8189..ebecb39c16 100644 --- a/src/core/lib/iomgr/resolve_address_posix.c +++ b/src/core/lib/iomgr/resolve_address_posix.c @@ -34,8 +34,8 @@ #include #ifdef GPR_POSIX_SOCKET -#include "src/core/iomgr/resolve_address.h" -#include "src/core/iomgr/sockaddr.h" +#include "src/core/lib/iomgr/resolve_address.h" +#include "src/core/lib/iomgr/sockaddr.h" #include #include @@ -47,12 +47,12 @@ #include #include #include -#include "src/core/iomgr/executor.h" -#include "src/core/iomgr/iomgr_internal.h" -#include "src/core/iomgr/sockaddr_utils.h" -#include "src/core/iomgr/unix_sockets_posix.h" -#include "src/core/support/block_annotate.h" -#include "src/core/support/string.h" +#include "src/core/lib/iomgr/executor.h" +#include "src/core/lib/iomgr/iomgr_internal.h" +#include "src/core/lib/iomgr/sockaddr_utils.h" +#include "src/core/lib/iomgr/unix_sockets_posix.h" +#include "src/core/lib/support/block_annotate.h" +#include "src/core/lib/support/string.h" typedef struct { char *name; diff --git a/src/core/lib/iomgr/resolve_address_windows.c b/src/core/lib/iomgr/resolve_address_windows.c index 472e797163..bde1f1b7f7 100644 --- a/src/core/lib/iomgr/resolve_address_windows.c +++ b/src/core/lib/iomgr/resolve_address_windows.c @@ -34,8 +34,8 @@ #include #ifdef GPR_WINSOCK_SOCKET -#include "src/core/iomgr/resolve_address.h" -#include "src/core/iomgr/sockaddr.h" +#include "src/core/lib/iomgr/resolve_address.h" +#include "src/core/lib/iomgr/sockaddr.h" #include #include @@ -47,11 +47,11 @@ #include #include #include -#include "src/core/iomgr/executor.h" -#include "src/core/iomgr/iomgr_internal.h" -#include "src/core/iomgr/sockaddr_utils.h" -#include "src/core/support/block_annotate.h" -#include "src/core/support/string.h" +#include "src/core/lib/iomgr/executor.h" +#include "src/core/lib/iomgr/iomgr_internal.h" +#include "src/core/lib/iomgr/sockaddr_utils.h" +#include "src/core/lib/support/block_annotate.h" +#include "src/core/lib/support/string.h" typedef struct { char *name; diff --git a/src/core/lib/iomgr/sockaddr.h b/src/core/lib/iomgr/sockaddr.h index e59a98e4ae..66a930ee6a 100644 --- a/src/core/lib/iomgr/sockaddr.h +++ b/src/core/lib/iomgr/sockaddr.h @@ -37,11 +37,11 @@ #include #ifdef GPR_WIN32 -#include "src/core/iomgr/sockaddr_win32.h" +#include "src/core/lib/iomgr/sockaddr_win32.h" #endif #ifdef GPR_POSIX_SOCKETADDR -#include "src/core/iomgr/sockaddr_posix.h" +#include "src/core/lib/iomgr/sockaddr_posix.h" #endif #endif /* GRPC_CORE_LIB_IOMGR_SOCKADDR_H */ diff --git a/src/core/lib/iomgr/sockaddr_utils.c b/src/core/lib/iomgr/sockaddr_utils.c index a3c3a874c1..127d95c618 100644 --- a/src/core/lib/iomgr/sockaddr_utils.c +++ b/src/core/lib/iomgr/sockaddr_utils.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/sockaddr_utils.h" +#include "src/core/lib/iomgr/sockaddr_utils.h" #include #include @@ -42,8 +42,8 @@ #include #include -#include "src/core/iomgr/unix_sockets_posix.h" -#include "src/core/support/string.h" +#include "src/core/lib/iomgr/unix_sockets_posix.h" +#include "src/core/lib/support/string.h" static const uint8_t kV4MappedPrefix[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff}; diff --git a/src/core/lib/iomgr/sockaddr_utils.h b/src/core/lib/iomgr/sockaddr_utils.h index 58f30fca2b..20a3e3bec3 100644 --- a/src/core/lib/iomgr/sockaddr_utils.h +++ b/src/core/lib/iomgr/sockaddr_utils.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_IOMGR_SOCKADDR_UTILS_H #define GRPC_CORE_LIB_IOMGR_SOCKADDR_UTILS_H -#include "src/core/iomgr/sockaddr.h" +#include "src/core/lib/iomgr/sockaddr.h" /* Returns true if addr is an IPv4-mapped IPv6 address within the ::ffff:0.0.0.0/96 range, or false otherwise. diff --git a/src/core/lib/iomgr/socket_utils_common_posix.c b/src/core/lib/iomgr/socket_utils_common_posix.c index 570daccc9e..9dbc2784e4 100644 --- a/src/core/lib/iomgr/socket_utils_common_posix.c +++ b/src/core/lib/iomgr/socket_utils_common_posix.c @@ -35,7 +35,7 @@ #ifdef GPR_POSIX_SOCKET -#include "src/core/iomgr/socket_utils_posix.h" +#include "src/core/lib/iomgr/socket_utils_posix.h" #include #include @@ -53,8 +53,8 @@ #include #include #include -#include "src/core/iomgr/sockaddr_utils.h" -#include "src/core/support/string.h" +#include "src/core/lib/iomgr/sockaddr_utils.h" +#include "src/core/lib/support/string.h" /* set a socket to non blocking mode */ int grpc_set_socket_nonblocking(int fd, int non_blocking) { diff --git a/src/core/lib/iomgr/socket_utils_linux.c b/src/core/lib/iomgr/socket_utils_linux.c index e16885f231..e7dfe892ca 100644 --- a/src/core/lib/iomgr/socket_utils_linux.c +++ b/src/core/lib/iomgr/socket_utils_linux.c @@ -35,7 +35,7 @@ #ifdef GPR_LINUX_SOCKETUTILS -#include "src/core/iomgr/socket_utils_posix.h" +#include "src/core/lib/iomgr/socket_utils_posix.h" #include #include diff --git a/src/core/lib/iomgr/socket_utils_posix.c b/src/core/lib/iomgr/socket_utils_posix.c index 794a5804ac..b2fa00c5c1 100644 --- a/src/core/lib/iomgr/socket_utils_posix.c +++ b/src/core/lib/iomgr/socket_utils_posix.c @@ -35,7 +35,7 @@ #ifdef GPR_POSIX_SOCKETUTILS -#include "src/core/iomgr/socket_utils_posix.h" +#include "src/core/lib/iomgr/socket_utils_posix.h" #include #include diff --git a/src/core/lib/iomgr/socket_windows.c b/src/core/lib/iomgr/socket_windows.c index c1f419e273..1023a6d4f8 100644 --- a/src/core/lib/iomgr/socket_windows.c +++ b/src/core/lib/iomgr/socket_windows.c @@ -45,11 +45,11 @@ #include #include -#include "src/core/iomgr/iocp_windows.h" -#include "src/core/iomgr/iomgr_internal.h" -#include "src/core/iomgr/pollset.h" -#include "src/core/iomgr/pollset_windows.h" -#include "src/core/iomgr/socket_windows.h" +#include "src/core/lib/iomgr/iocp_windows.h" +#include "src/core/lib/iomgr/iomgr_internal.h" +#include "src/core/lib/iomgr/pollset.h" +#include "src/core/lib/iomgr/pollset_windows.h" +#include "src/core/lib/iomgr/socket_windows.h" grpc_winsocket *grpc_winsocket_create(SOCKET socket, const char *name) { char *final_name; diff --git a/src/core/lib/iomgr/socket_windows.h b/src/core/lib/iomgr/socket_windows.h index 033aec695f..74447896c9 100644 --- a/src/core/lib/iomgr/socket_windows.h +++ b/src/core/lib/iomgr/socket_windows.h @@ -40,8 +40,8 @@ #include #include -#include "src/core/iomgr/exec_ctx.h" -#include "src/core/iomgr/iomgr_internal.h" +#include "src/core/lib/iomgr/exec_ctx.h" +#include "src/core/lib/iomgr/iomgr_internal.h" /* This holds the data for an outstanding read or write on a socket. The mutex to protect the concurrent access to that data is the one diff --git a/src/core/lib/iomgr/tcp_client.h b/src/core/lib/iomgr/tcp_client.h index 8f012e248c..6bbe26445a 100644 --- a/src/core/lib/iomgr/tcp_client.h +++ b/src/core/lib/iomgr/tcp_client.h @@ -35,9 +35,9 @@ #define GRPC_CORE_LIB_IOMGR_TCP_CLIENT_H #include -#include "src/core/iomgr/endpoint.h" -#include "src/core/iomgr/pollset_set.h" -#include "src/core/iomgr/sockaddr.h" +#include "src/core/lib/iomgr/endpoint.h" +#include "src/core/lib/iomgr/pollset_set.h" +#include "src/core/lib/iomgr/sockaddr.h" /* Asynchronously connect to an address (specified as (addr, len)), and call cb with arg and the completed connection when done (or call cb with arg and diff --git a/src/core/lib/iomgr/tcp_client_posix.c b/src/core/lib/iomgr/tcp_client_posix.c index 1d3f9b6555..b8ef643298 100644 --- a/src/core/lib/iomgr/tcp_client_posix.c +++ b/src/core/lib/iomgr/tcp_client_posix.c @@ -35,7 +35,7 @@ #ifdef GPR_POSIX_SOCKET -#include "src/core/iomgr/tcp_client.h" +#include "src/core/lib/iomgr/tcp_client.h" #include #include @@ -47,15 +47,15 @@ #include #include -#include "src/core/iomgr/iomgr_posix.h" -#include "src/core/iomgr/pollset_posix.h" -#include "src/core/iomgr/pollset_set_posix.h" -#include "src/core/iomgr/sockaddr_utils.h" -#include "src/core/iomgr/socket_utils_posix.h" -#include "src/core/iomgr/tcp_posix.h" -#include "src/core/iomgr/timer.h" -#include "src/core/iomgr/unix_sockets_posix.h" -#include "src/core/support/string.h" +#include "src/core/lib/iomgr/iomgr_posix.h" +#include "src/core/lib/iomgr/pollset_posix.h" +#include "src/core/lib/iomgr/pollset_set_posix.h" +#include "src/core/lib/iomgr/sockaddr_utils.h" +#include "src/core/lib/iomgr/socket_utils_posix.h" +#include "src/core/lib/iomgr/tcp_posix.h" +#include "src/core/lib/iomgr/timer.h" +#include "src/core/lib/iomgr/unix_sockets_posix.h" +#include "src/core/lib/support/string.h" extern int grpc_tcp_trace; diff --git a/src/core/lib/iomgr/tcp_client_windows.c b/src/core/lib/iomgr/tcp_client_windows.c index da83f7b79c..86b8d58975 100644 --- a/src/core/lib/iomgr/tcp_client_windows.c +++ b/src/core/lib/iomgr/tcp_client_windows.c @@ -35,7 +35,7 @@ #ifdef GPR_WINSOCK_SOCKET -#include "src/core/iomgr/sockaddr_win32.h" +#include "src/core/lib/iomgr/sockaddr_win32.h" #include #include @@ -43,13 +43,13 @@ #include #include -#include "src/core/iomgr/iocp_windows.h" -#include "src/core/iomgr/sockaddr.h" -#include "src/core/iomgr/sockaddr_utils.h" -#include "src/core/iomgr/socket_windows.h" -#include "src/core/iomgr/tcp_client.h" -#include "src/core/iomgr/tcp_windows.h" -#include "src/core/iomgr/timer.h" +#include "src/core/lib/iomgr/iocp_windows.h" +#include "src/core/lib/iomgr/sockaddr.h" +#include "src/core/lib/iomgr/sockaddr_utils.h" +#include "src/core/lib/iomgr/socket_windows.h" +#include "src/core/lib/iomgr/tcp_client.h" +#include "src/core/lib/iomgr/tcp_windows.h" +#include "src/core/lib/iomgr/timer.h" typedef struct { grpc_closure *on_done; diff --git a/src/core/lib/iomgr/tcp_posix.c b/src/core/lib/iomgr/tcp_posix.c index e8f73811ce..1898d96901 100644 --- a/src/core/lib/iomgr/tcp_posix.c +++ b/src/core/lib/iomgr/tcp_posix.c @@ -35,7 +35,7 @@ #ifdef GPR_POSIX_SOCKET -#include "src/core/iomgr/tcp_posix.h" +#include "src/core/lib/iomgr/tcp_posix.h" #include #include @@ -51,11 +51,11 @@ #include #include -#include "src/core/debug/trace.h" -#include "src/core/iomgr/pollset_posix.h" -#include "src/core/iomgr/pollset_set_posix.h" -#include "src/core/profiling/timers.h" -#include "src/core/support/string.h" +#include "src/core/lib/debug/trace.h" +#include "src/core/lib/iomgr/pollset_posix.h" +#include "src/core/lib/iomgr/pollset_set_posix.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/support/string.h" #ifdef GPR_HAVE_MSG_NOSIGNAL #define SENDMSG_FLAGS MSG_NOSIGNAL diff --git a/src/core/lib/iomgr/tcp_posix.h b/src/core/lib/iomgr/tcp_posix.h index b12fef5ecd..09c4436f1f 100644 --- a/src/core/lib/iomgr/tcp_posix.h +++ b/src/core/lib/iomgr/tcp_posix.h @@ -44,8 +44,8 @@ otherwise specified. */ -#include "src/core/iomgr/endpoint.h" -#include "src/core/iomgr/fd_posix.h" +#include "src/core/lib/iomgr/endpoint.h" +#include "src/core/lib/iomgr/fd_posix.h" #define GRPC_TCP_DEFAULT_READ_SLICE_SIZE 8192 diff --git a/src/core/lib/iomgr/tcp_server.h b/src/core/lib/iomgr/tcp_server.h index e27fd233cd..81edb61997 100644 --- a/src/core/lib/iomgr/tcp_server.h +++ b/src/core/lib/iomgr/tcp_server.h @@ -34,8 +34,8 @@ #ifndef GRPC_CORE_LIB_IOMGR_TCP_SERVER_H #define GRPC_CORE_LIB_IOMGR_TCP_SERVER_H -#include "src/core/iomgr/closure.h" -#include "src/core/iomgr/endpoint.h" +#include "src/core/lib/iomgr/closure.h" +#include "src/core/lib/iomgr/endpoint.h" /* Forward decl of grpc_tcp_server */ typedef struct grpc_tcp_server grpc_tcp_server; diff --git a/src/core/lib/iomgr/tcp_server_posix.c b/src/core/lib/iomgr/tcp_server_posix.c index 74ee68a6f1..ef1bf9aa94 100644 --- a/src/core/lib/iomgr/tcp_server_posix.c +++ b/src/core/lib/iomgr/tcp_server_posix.c @@ -40,7 +40,7 @@ #ifdef GPR_POSIX_SOCKET -#include "src/core/iomgr/tcp_server.h" +#include "src/core/lib/iomgr/tcp_server.h" #include #include @@ -59,13 +59,13 @@ #include #include #include -#include "src/core/iomgr/pollset_posix.h" -#include "src/core/iomgr/resolve_address.h" -#include "src/core/iomgr/sockaddr_utils.h" -#include "src/core/iomgr/socket_utils_posix.h" -#include "src/core/iomgr/tcp_posix.h" -#include "src/core/iomgr/unix_sockets_posix.h" -#include "src/core/support/string.h" +#include "src/core/lib/iomgr/pollset_posix.h" +#include "src/core/lib/iomgr/resolve_address.h" +#include "src/core/lib/iomgr/sockaddr_utils.h" +#include "src/core/lib/iomgr/socket_utils_posix.h" +#include "src/core/lib/iomgr/tcp_posix.h" +#include "src/core/lib/iomgr/unix_sockets_posix.h" +#include "src/core/lib/support/string.h" #define MIN_SAFE_ACCEPT_QUEUE_SIZE 100 diff --git a/src/core/lib/iomgr/tcp_server_windows.c b/src/core/lib/iomgr/tcp_server_windows.c index a4abc5b974..3d6a29b2e2 100644 --- a/src/core/lib/iomgr/tcp_server_windows.c +++ b/src/core/lib/iomgr/tcp_server_windows.c @@ -37,7 +37,7 @@ #include -#include "src/core/iomgr/sockaddr_utils.h" +#include "src/core/lib/iomgr/sockaddr_utils.h" #include #include @@ -46,11 +46,11 @@ #include #include -#include "src/core/iomgr/iocp_windows.h" -#include "src/core/iomgr/pollset_windows.h" -#include "src/core/iomgr/socket_windows.h" -#include "src/core/iomgr/tcp_server.h" -#include "src/core/iomgr/tcp_windows.h" +#include "src/core/lib/iomgr/iocp_windows.h" +#include "src/core/lib/iomgr/pollset_windows.h" +#include "src/core/lib/iomgr/socket_windows.h" +#include "src/core/lib/iomgr/tcp_server.h" +#include "src/core/lib/iomgr/tcp_windows.h" #define MIN_SAFE_ACCEPT_QUEUE_SIZE 100 diff --git a/src/core/lib/iomgr/tcp_windows.c b/src/core/lib/iomgr/tcp_windows.c index 9b1db5fa7e..c1ce725f2c 100644 --- a/src/core/lib/iomgr/tcp_windows.c +++ b/src/core/lib/iomgr/tcp_windows.c @@ -35,7 +35,7 @@ #ifdef GPR_WINSOCK_SOCKET -#include "src/core/iomgr/sockaddr_win32.h" +#include "src/core/lib/iomgr/sockaddr_win32.h" #include #include @@ -44,12 +44,12 @@ #include #include -#include "src/core/iomgr/iocp_windows.h" -#include "src/core/iomgr/sockaddr.h" -#include "src/core/iomgr/sockaddr_utils.h" -#include "src/core/iomgr/socket_windows.h" -#include "src/core/iomgr/tcp_client.h" -#include "src/core/iomgr/timer.h" +#include "src/core/lib/iomgr/iocp_windows.h" +#include "src/core/lib/iomgr/sockaddr.h" +#include "src/core/lib/iomgr/sockaddr_utils.h" +#include "src/core/lib/iomgr/socket_windows.h" +#include "src/core/lib/iomgr/tcp_client.h" +#include "src/core/lib/iomgr/timer.h" static int set_non_block(SOCKET sock) { int status; diff --git a/src/core/lib/iomgr/tcp_windows.h b/src/core/lib/iomgr/tcp_windows.h index c9e508f296..7a9ebd85eb 100644 --- a/src/core/lib/iomgr/tcp_windows.h +++ b/src/core/lib/iomgr/tcp_windows.h @@ -44,8 +44,8 @@ otherwise specified. */ -#include "src/core/iomgr/endpoint.h" -#include "src/core/iomgr/socket_windows.h" +#include "src/core/lib/iomgr/endpoint.h" +#include "src/core/lib/iomgr/socket_windows.h" /* Create a tcp endpoint given a winsock handle. * Takes ownership of the handle. diff --git a/src/core/lib/iomgr/time_averaged_stats.c b/src/core/lib/iomgr/time_averaged_stats.c index 014162cc3b..f24d68087e 100644 --- a/src/core/lib/iomgr/time_averaged_stats.c +++ b/src/core/lib/iomgr/time_averaged_stats.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/time_averaged_stats.h" +#include "src/core/lib/iomgr/time_averaged_stats.h" void grpc_time_averaged_stats_init(grpc_time_averaged_stats* stats, double init_avg, double regress_weight, diff --git a/src/core/lib/iomgr/timer.c b/src/core/lib/iomgr/timer.c index f444643428..4748f9b270 100644 --- a/src/core/lib/iomgr/timer.c +++ b/src/core/lib/iomgr/timer.c @@ -31,13 +31,13 @@ * */ -#include "src/core/iomgr/timer.h" +#include "src/core/lib/iomgr/timer.h" #include #include #include -#include "src/core/iomgr/time_averaged_stats.h" -#include "src/core/iomgr/timer_heap.h" +#include "src/core/lib/iomgr/time_averaged_stats.h" +#include "src/core/lib/iomgr/timer_heap.h" #define INVALID_HEAP_INDEX 0xffffffffu diff --git a/src/core/lib/iomgr/timer.h b/src/core/lib/iomgr/timer.h index 616a886743..54f301c5ed 100644 --- a/src/core/lib/iomgr/timer.h +++ b/src/core/lib/iomgr/timer.h @@ -36,8 +36,8 @@ #include #include -#include "src/core/iomgr/exec_ctx.h" -#include "src/core/iomgr/iomgr.h" +#include "src/core/lib/iomgr/exec_ctx.h" +#include "src/core/lib/iomgr/iomgr.h" typedef struct grpc_timer { gpr_timespec deadline; diff --git a/src/core/lib/iomgr/timer_heap.c b/src/core/lib/iomgr/timer_heap.c index b5df566c45..d43b6ccf75 100644 --- a/src/core/lib/iomgr/timer_heap.c +++ b/src/core/lib/iomgr/timer_heap.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/timer_heap.h" +#include "src/core/lib/iomgr/timer_heap.h" #include diff --git a/src/core/lib/iomgr/timer_heap.h b/src/core/lib/iomgr/timer_heap.h index d6b4f083d8..d5112cf0de 100644 --- a/src/core/lib/iomgr/timer_heap.h +++ b/src/core/lib/iomgr/timer_heap.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_IOMGR_TIMER_HEAP_H #define GRPC_CORE_LIB_IOMGR_TIMER_HEAP_H -#include "src/core/iomgr/timer.h" +#include "src/core/lib/iomgr/timer.h" typedef struct { grpc_timer **timers; diff --git a/src/core/lib/iomgr/udp_server.c b/src/core/lib/iomgr/udp_server.c index 174159170f..3d8bcc9c81 100644 --- a/src/core/lib/iomgr/udp_server.c +++ b/src/core/lib/iomgr/udp_server.c @@ -41,7 +41,7 @@ #ifdef GRPC_NEED_UDP #ifdef GPR_POSIX_SOCKET -#include "src/core/iomgr/udp_server.h" +#include "src/core/lib/iomgr/udp_server.h" #include #include @@ -60,13 +60,13 @@ #include #include #include -#include "src/core/iomgr/fd_posix.h" -#include "src/core/iomgr/pollset_posix.h" -#include "src/core/iomgr/resolve_address.h" -#include "src/core/iomgr/sockaddr_utils.h" -#include "src/core/iomgr/socket_utils_posix.h" -#include "src/core/iomgr/unix_sockets_posix.h" -#include "src/core/support/string.h" +#include "src/core/lib/iomgr/fd_posix.h" +#include "src/core/lib/iomgr/pollset_posix.h" +#include "src/core/lib/iomgr/resolve_address.h" +#include "src/core/lib/iomgr/sockaddr_utils.h" +#include "src/core/lib/iomgr/socket_utils_posix.h" +#include "src/core/lib/iomgr/unix_sockets_posix.h" +#include "src/core/lib/support/string.h" #define INIT_PORT_CAP 2 diff --git a/src/core/lib/iomgr/udp_server.h b/src/core/lib/iomgr/udp_server.h index ac70124727..316845ad66 100644 --- a/src/core/lib/iomgr/udp_server.h +++ b/src/core/lib/iomgr/udp_server.h @@ -34,8 +34,8 @@ #ifndef GRPC_CORE_LIB_IOMGR_UDP_SERVER_H #define GRPC_CORE_LIB_IOMGR_UDP_SERVER_H -#include "src/core/iomgr/endpoint.h" -#include "src/core/iomgr/fd_posix.h" +#include "src/core/lib/iomgr/endpoint.h" +#include "src/core/lib/iomgr/fd_posix.h" /* Forward decl of struct grpc_server */ /* This is not typedef'ed to avoid a typedef-redefinition error */ diff --git a/src/core/lib/iomgr/unix_sockets_posix.c b/src/core/lib/iomgr/unix_sockets_posix.c index 174a7e7abf..42e44989e0 100644 --- a/src/core/lib/iomgr/unix_sockets_posix.c +++ b/src/core/lib/iomgr/unix_sockets_posix.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/unix_sockets_posix.h" +#include "src/core/lib/iomgr/unix_sockets_posix.h" #ifdef GPR_HAVE_UNIX_SOCKET diff --git a/src/core/lib/iomgr/unix_sockets_posix.h b/src/core/lib/iomgr/unix_sockets_posix.h index 6382c92480..752cab85a5 100644 --- a/src/core/lib/iomgr/unix_sockets_posix.h +++ b/src/core/lib/iomgr/unix_sockets_posix.h @@ -38,10 +38,10 @@ #include -#include "src/core/client_config/resolver_factory.h" -#include "src/core/client_config/uri_parser.h" -#include "src/core/iomgr/resolve_address.h" -#include "src/core/iomgr/sockaddr.h" +#include "src/core/lib/client_config/resolver_factory.h" +#include "src/core/lib/client_config/uri_parser.h" +#include "src/core/lib/iomgr/resolve_address.h" +#include "src/core/lib/iomgr/sockaddr.h" void grpc_create_socketpair_if_unix(int sv[2]); diff --git a/src/core/lib/iomgr/unix_sockets_posix_noop.c b/src/core/lib/iomgr/unix_sockets_posix_noop.c index 045467bea4..06f6ee05e7 100644 --- a/src/core/lib/iomgr/unix_sockets_posix_noop.c +++ b/src/core/lib/iomgr/unix_sockets_posix_noop.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/unix_sockets_posix.h" +#include "src/core/lib/iomgr/unix_sockets_posix.h" #ifndef GPR_HAVE_UNIX_SOCKET diff --git a/src/core/lib/iomgr/wakeup_fd_eventfd.c b/src/core/lib/iomgr/wakeup_fd_eventfd.c index f4662965cd..41ded0ca4d 100644 --- a/src/core/lib/iomgr/wakeup_fd_eventfd.c +++ b/src/core/lib/iomgr/wakeup_fd_eventfd.c @@ -41,8 +41,8 @@ #include -#include "src/core/iomgr/wakeup_fd_posix.h" -#include "src/core/profiling/timers.h" +#include "src/core/lib/iomgr/wakeup_fd_posix.h" +#include "src/core/lib/profiling/timers.h" static void eventfd_create(grpc_wakeup_fd* fd_info) { int efd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); diff --git a/src/core/lib/iomgr/wakeup_fd_nospecial.c b/src/core/lib/iomgr/wakeup_fd_nospecial.c index 7b2be9ed52..39defa65c6 100644 --- a/src/core/lib/iomgr/wakeup_fd_nospecial.c +++ b/src/core/lib/iomgr/wakeup_fd_nospecial.c @@ -41,7 +41,7 @@ #ifdef GPR_POSIX_NO_SPECIAL_WAKEUP_FD #include -#include "src/core/iomgr/wakeup_fd_posix.h" +#include "src/core/lib/iomgr/wakeup_fd_posix.h" static int check_availability_invalid(void) { return 0; } diff --git a/src/core/lib/iomgr/wakeup_fd_pipe.c b/src/core/lib/iomgr/wakeup_fd_pipe.c index dd2fd1f057..820919e4dd 100644 --- a/src/core/lib/iomgr/wakeup_fd_pipe.c +++ b/src/core/lib/iomgr/wakeup_fd_pipe.c @@ -35,7 +35,7 @@ #ifdef GPR_POSIX_WAKEUP_FD -#include "src/core/iomgr/wakeup_fd_posix.h" +#include "src/core/lib/iomgr/wakeup_fd_posix.h" #include #include @@ -43,7 +43,7 @@ #include -#include "src/core/iomgr/socket_utils_posix.h" +#include "src/core/lib/iomgr/socket_utils_posix.h" static void pipe_init(grpc_wakeup_fd* fd_info) { int pipefd[2]; diff --git a/src/core/lib/iomgr/wakeup_fd_pipe.h b/src/core/lib/iomgr/wakeup_fd_pipe.h index dd8275800a..bbdb1fc448 100644 --- a/src/core/lib/iomgr/wakeup_fd_pipe.h +++ b/src/core/lib/iomgr/wakeup_fd_pipe.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_IOMGR_WAKEUP_FD_PIPE_H #define GRPC_CORE_LIB_IOMGR_WAKEUP_FD_PIPE_H -#include "src/core/iomgr/wakeup_fd_posix.h" +#include "src/core/lib/iomgr/wakeup_fd_posix.h" extern grpc_wakeup_fd_vtable grpc_pipe_wakeup_fd_vtable; diff --git a/src/core/lib/iomgr/wakeup_fd_posix.c b/src/core/lib/iomgr/wakeup_fd_posix.c index 07778c408e..c4d174fb34 100644 --- a/src/core/lib/iomgr/wakeup_fd_posix.c +++ b/src/core/lib/iomgr/wakeup_fd_posix.c @@ -36,8 +36,8 @@ #ifdef GPR_POSIX_WAKEUP_FD #include -#include "src/core/iomgr/wakeup_fd_pipe.h" -#include "src/core/iomgr/wakeup_fd_posix.h" +#include "src/core/lib/iomgr/wakeup_fd_pipe.h" +#include "src/core/lib/iomgr/wakeup_fd_posix.h" static const grpc_wakeup_fd_vtable *wakeup_fd_vtable = NULL; int grpc_allow_specialized_wakeup_fd = 1; diff --git a/src/core/lib/iomgr/workqueue.h b/src/core/lib/iomgr/workqueue.h index d11fc77d82..9c420c57de 100644 --- a/src/core/lib/iomgr/workqueue.h +++ b/src/core/lib/iomgr/workqueue.h @@ -34,17 +34,17 @@ #ifndef GRPC_CORE_LIB_IOMGR_WORKQUEUE_H #define GRPC_CORE_LIB_IOMGR_WORKQUEUE_H -#include "src/core/iomgr/closure.h" -#include "src/core/iomgr/exec_ctx.h" -#include "src/core/iomgr/iomgr.h" -#include "src/core/iomgr/pollset.h" +#include "src/core/lib/iomgr/closure.h" +#include "src/core/lib/iomgr/exec_ctx.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/iomgr/pollset.h" #ifdef GPR_POSIX_SOCKET -#include "src/core/iomgr/workqueue_posix.h" +#include "src/core/lib/iomgr/workqueue_posix.h" #endif #ifdef GPR_WIN32 -#include "src/core/iomgr/workqueue_windows.h" +#include "src/core/lib/iomgr/workqueue_windows.h" #endif /* grpc_workqueue is forward declared in exec_ctx.h */ diff --git a/src/core/lib/iomgr/workqueue_posix.c b/src/core/lib/iomgr/workqueue_posix.c index 2b42e6d4fb..76830ef12d 100644 --- a/src/core/lib/iomgr/workqueue_posix.c +++ b/src/core/lib/iomgr/workqueue_posix.c @@ -35,7 +35,7 @@ #ifdef GPR_POSIX_SOCKET -#include "src/core/iomgr/workqueue.h" +#include "src/core/lib/iomgr/workqueue.h" #include @@ -43,8 +43,8 @@ #include #include -#include "src/core/iomgr/fd_posix.h" -#include "src/core/iomgr/pollset_posix.h" +#include "src/core/lib/iomgr/fd_posix.h" +#include "src/core/lib/iomgr/pollset_posix.h" static void on_readable(grpc_exec_ctx *exec_ctx, void *arg, bool success); diff --git a/src/core/lib/iomgr/workqueue_posix.h b/src/core/lib/iomgr/workqueue_posix.h index 02e1dad44f..956de8fb27 100644 --- a/src/core/lib/iomgr/workqueue_posix.h +++ b/src/core/lib/iomgr/workqueue_posix.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_IOMGR_WORKQUEUE_POSIX_H #define GRPC_CORE_LIB_IOMGR_WORKQUEUE_POSIX_H -#include "src/core/iomgr/wakeup_fd_posix.h" +#include "src/core/lib/iomgr/wakeup_fd_posix.h" struct grpc_fd; diff --git a/src/core/lib/iomgr/workqueue_windows.c b/src/core/lib/iomgr/workqueue_windows.c index dd7fac8b35..6697f93498 100644 --- a/src/core/lib/iomgr/workqueue_windows.c +++ b/src/core/lib/iomgr/workqueue_windows.c @@ -35,6 +35,6 @@ #ifdef GPR_WIN32 -#include "src/core/iomgr/workqueue.h" +#include "src/core/lib/iomgr/workqueue.h" #endif /* GPR_WIN32 */ diff --git a/src/core/lib/json/json.c b/src/core/lib/json/json.c index b31ee49562..9793045d91 100644 --- a/src/core/lib/json/json.c +++ b/src/core/lib/json/json.c @@ -35,7 +35,7 @@ #include -#include "src/core/json/json.h" +#include "src/core/lib/json/json.h" grpc_json *grpc_json_create(grpc_json_type type) { grpc_json *json = gpr_malloc(sizeof(*json)); diff --git a/src/core/lib/json/json.h b/src/core/lib/json/json.h index 89d15846ce..41d87dd5ce 100644 --- a/src/core/lib/json/json.h +++ b/src/core/lib/json/json.h @@ -36,7 +36,7 @@ #include -#include "src/core/json/json_common.h" +#include "src/core/lib/json/json_common.h" /* A tree-like structure to hold json values. The key and value pointers * are not owned by it. diff --git a/src/core/lib/json/json_reader.c b/src/core/lib/json/json_reader.c index 861323d10c..0807f029ce 100644 --- a/src/core/lib/json/json_reader.c +++ b/src/core/lib/json/json_reader.c @@ -37,7 +37,7 @@ #include -#include "src/core/json/json_reader.h" +#include "src/core/lib/json/json_reader.h" static void json_reader_string_clear(grpc_json_reader *reader) { reader->vtable->string_clear(reader->userdata); diff --git a/src/core/lib/json/json_reader.h b/src/core/lib/json/json_reader.h index a49d6fef68..37a838889d 100644 --- a/src/core/lib/json/json_reader.h +++ b/src/core/lib/json/json_reader.h @@ -35,7 +35,7 @@ #define GRPC_CORE_LIB_JSON_JSON_READER_H #include -#include "src/core/json/json_common.h" +#include "src/core/lib/json/json_common.h" typedef enum { GRPC_JSON_STATE_OBJECT_KEY_BEGIN, diff --git a/src/core/lib/json/json_string.c b/src/core/lib/json/json_string.c index d4ebce18e1..8e6f1253dc 100644 --- a/src/core/lib/json/json_string.c +++ b/src/core/lib/json/json_string.c @@ -37,9 +37,9 @@ #include #include -#include "src/core/json/json.h" -#include "src/core/json/json_reader.h" -#include "src/core/json/json_writer.h" +#include "src/core/lib/json/json.h" +#include "src/core/lib/json/json_reader.h" +#include "src/core/lib/json/json_writer.h" /* The json reader will construct a bunch of grpc_json objects and * link them all up together in a tree-like structure that will represent diff --git a/src/core/lib/json/json_writer.c b/src/core/lib/json/json_writer.c index abcb3efd98..d614a72fc4 100644 --- a/src/core/lib/json/json_writer.c +++ b/src/core/lib/json/json_writer.c @@ -35,7 +35,7 @@ #include -#include "src/core/json/json_writer.h" +#include "src/core/lib/json/json_writer.h" static void json_writer_output_char(grpc_json_writer *writer, char c) { writer->vtable->output_char(writer->userdata, c); diff --git a/src/core/lib/json/json_writer.h b/src/core/lib/json/json_writer.h index 90b6bc753c..f90e79cd74 100644 --- a/src/core/lib/json/json_writer.h +++ b/src/core/lib/json/json_writer.h @@ -48,7 +48,7 @@ #include -#include "src/core/json/json_common.h" +#include "src/core/lib/json/json_common.h" typedef struct grpc_json_writer_vtable { /* Adds a character to the output stream. */ diff --git a/src/core/lib/profiling/basic_timers.c b/src/core/lib/profiling/basic_timers.c index 3067f52c21..15a9584981 100644 --- a/src/core/lib/profiling/basic_timers.c +++ b/src/core/lib/profiling/basic_timers.c @@ -35,7 +35,7 @@ #ifdef GRPC_BASIC_PROFILER -#include "src/core/profiling/timers.h" +#include "src/core/lib/profiling/timers.h" #include #include diff --git a/src/core/lib/profiling/stap_timers.c b/src/core/lib/profiling/stap_timers.c index d67541a339..f55c1a569a 100644 --- a/src/core/lib/profiling/stap_timers.c +++ b/src/core/lib/profiling/stap_timers.c @@ -35,11 +35,11 @@ #ifdef GRPC_STAP_PROFILER -#include "src/core/profiling/timers.h" +#include "src/core/lib/profiling/timers.h" #include /* Generated from src/core/profiling/stap_probes.d */ -#include "src/core/profiling/stap_probes.h" +#include "src/core/lib/profiling/stap_probes.h" /* Latency profiler API implementation. */ void gpr_timer_add_mark(int tag, const char *tagstr, void *id, const char *file, diff --git a/src/core/lib/proto/grpc/lb/v0/load_balancer.pb.c b/src/core/lib/proto/grpc/lb/v0/load_balancer.pb.c index 59aae30cff..8f82141f96 100644 --- a/src/core/lib/proto/grpc/lb/v0/load_balancer.pb.c +++ b/src/core/lib/proto/grpc/lb/v0/load_balancer.pb.c @@ -33,7 +33,7 @@ /* Automatically generated nanopb constant definitions */ /* Generated by nanopb-0.3.5-dev */ -#include "src/core/proto/grpc/lb/v0/load_balancer.pb.h" +#include "src/core/lib/proto/grpc/lb/v0/load_balancer.pb.h" #if PB_PROTO_HEADER_VERSION != 30 #error Regenerate this file with the current version of nanopb generator. diff --git a/src/core/lib/security/auth_filters.h b/src/core/lib/security/auth_filters.h index 0fb19e7382..162b60e2c8 100644 --- a/src/core/lib/security/auth_filters.h +++ b/src/core/lib/security/auth_filters.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_SECURITY_AUTH_FILTERS_H #define GRPC_CORE_LIB_SECURITY_AUTH_FILTERS_H -#include "src/core/channel/channel_stack.h" +#include "src/core/lib/channel/channel_stack.h" extern const grpc_channel_filter grpc_client_auth_filter; extern const grpc_channel_filter grpc_server_auth_filter; diff --git a/src/core/lib/security/b64.c b/src/core/lib/security/b64.c index c40b528e2f..1d3879534c 100644 --- a/src/core/lib/security/b64.c +++ b/src/core/lib/security/b64.c @@ -31,7 +31,7 @@ * */ -#include "src/core/security/b64.h" +#include "src/core/lib/security/b64.h" #include #include diff --git a/src/core/lib/security/client_auth_filter.c b/src/core/lib/security/client_auth_filter.c index e2c23ef98d..b9e5bf0339 100644 --- a/src/core/lib/security/client_auth_filter.c +++ b/src/core/lib/security/client_auth_filter.c @@ -31,7 +31,7 @@ * */ -#include "src/core/security/auth_filters.h" +#include "src/core/lib/security/auth_filters.h" #include @@ -39,13 +39,13 @@ #include #include -#include "src/core/channel/channel_stack.h" -#include "src/core/security/credentials.h" -#include "src/core/security/security_connector.h" -#include "src/core/security/security_context.h" -#include "src/core/support/string.h" -#include "src/core/surface/call.h" -#include "src/core/transport/static_metadata.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/security/security_connector.h" +#include "src/core/lib/security/security_context.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/call.h" +#include "src/core/lib/transport/static_metadata.h" #define MAX_CREDENTIALS_METADATA_COUNT 4 diff --git a/src/core/lib/security/credentials.c b/src/core/lib/security/credentials.c index c8348bc12c..99a07e5c13 100644 --- a/src/core/lib/security/credentials.c +++ b/src/core/lib/security/credentials.c @@ -31,19 +31,19 @@ * */ -#include "src/core/security/credentials.h" +#include "src/core/lib/security/credentials.h" #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/channel/http_client_filter.h" -#include "src/core/http/httpcli.h" -#include "src/core/http/parser.h" -#include "src/core/iomgr/executor.h" -#include "src/core/json/json.h" -#include "src/core/support/string.h" -#include "src/core/surface/api_trace.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/channel/http_client_filter.h" +#include "src/core/lib/http/httpcli.h" +#include "src/core/lib/http/parser.h" +#include "src/core/lib/iomgr/executor.h" +#include "src/core/lib/json/json.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/api_trace.h" #include #include diff --git a/src/core/lib/security/credentials.h b/src/core/lib/security/credentials.h index c1f451ded1..7168b98942 100644 --- a/src/core/lib/security/credentials.h +++ b/src/core/lib/security/credentials.h @@ -37,12 +37,12 @@ #include #include #include -#include "src/core/transport/metadata_batch.h" +#include "src/core/lib/transport/metadata_batch.h" -#include "src/core/http/httpcli.h" -#include "src/core/http/parser.h" -#include "src/core/security/json_token.h" -#include "src/core/security/security_connector.h" +#include "src/core/lib/http/httpcli.h" +#include "src/core/lib/http/parser.h" +#include "src/core/lib/security/json_token.h" +#include "src/core/lib/security/security_connector.h" struct grpc_http_response; diff --git a/src/core/lib/security/credentials_metadata.c b/src/core/lib/security/credentials_metadata.c index 524c003eca..c3bfcb11b5 100644 --- a/src/core/lib/security/credentials_metadata.c +++ b/src/core/lib/security/credentials_metadata.c @@ -31,7 +31,7 @@ * */ -#include "src/core/security/credentials.h" +#include "src/core/lib/security/credentials.h" #include diff --git a/src/core/lib/security/credentials_posix.c b/src/core/lib/security/credentials_posix.c index 488e60c3bc..b758cd0a1a 100644 --- a/src/core/lib/security/credentials_posix.c +++ b/src/core/lib/security/credentials_posix.c @@ -35,14 +35,14 @@ #ifdef GPR_POSIX_FILE -#include "src/core/security/credentials.h" +#include "src/core/lib/security/credentials.h" #include #include #include -#include "src/core/support/env.h" -#include "src/core/support/string.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/support/string.h" char *grpc_get_well_known_google_credentials_file_path_impl(void) { char *result = NULL; diff --git a/src/core/lib/security/credentials_win32.c b/src/core/lib/security/credentials_win32.c index 646b0c21d6..a225ab0d7d 100644 --- a/src/core/lib/security/credentials_win32.c +++ b/src/core/lib/security/credentials_win32.c @@ -35,14 +35,14 @@ #ifdef GPR_WIN32 -#include "src/core/security/credentials.h" +#include "src/core/lib/security/credentials.h" #include #include #include -#include "src/core/support/env.h" -#include "src/core/support/string.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/support/string.h" char *grpc_get_well_known_google_credentials_file_path_impl(void) { char *result = NULL; diff --git a/src/core/lib/security/google_default_credentials.c b/src/core/lib/security/google_default_credentials.c index 3872e86993..5c342288cc 100644 --- a/src/core/lib/security/google_default_credentials.c +++ b/src/core/lib/security/google_default_credentials.c @@ -31,7 +31,7 @@ * */ -#include "src/core/security/credentials.h" +#include "src/core/lib/security/credentials.h" #include @@ -39,11 +39,11 @@ #include #include -#include "src/core/http/httpcli.h" -#include "src/core/http/parser.h" -#include "src/core/support/env.h" -#include "src/core/support/load_file.h" -#include "src/core/surface/api_trace.h" +#include "src/core/lib/http/httpcli.h" +#include "src/core/lib/http/parser.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/support/load_file.h" +#include "src/core/lib/surface/api_trace.h" /* -- Constants. -- */ diff --git a/src/core/lib/security/handshake.c b/src/core/lib/security/handshake.c index 9fb10a0ecb..adb6d7fe4e 100644 --- a/src/core/lib/security/handshake.c +++ b/src/core/lib/security/handshake.c @@ -31,7 +31,7 @@ * */ -#include "src/core/security/handshake.h" +#include "src/core/lib/security/handshake.h" #include #include @@ -39,8 +39,8 @@ #include #include #include -#include "src/core/security/secure_endpoint.h" -#include "src/core/security/security_context.h" +#include "src/core/lib/security/secure_endpoint.h" +#include "src/core/lib/security/security_context.h" #define GRPC_INITIAL_HANDSHAKE_BUFFER_SIZE 256 diff --git a/src/core/lib/security/handshake.h b/src/core/lib/security/handshake.h index 2b1f8b9212..b5d7bb3282 100644 --- a/src/core/lib/security/handshake.h +++ b/src/core/lib/security/handshake.h @@ -34,8 +34,8 @@ #ifndef GRPC_CORE_LIB_SECURITY_HANDSHAKE_H #define GRPC_CORE_LIB_SECURITY_HANDSHAKE_H -#include "src/core/iomgr/endpoint.h" -#include "src/core/security/security_connector.h" +#include "src/core/lib/iomgr/endpoint.h" +#include "src/core/lib/security/security_connector.h" /* Calls the callback upon completion. Takes owership of handshaker. */ void grpc_do_security_handshake(grpc_exec_ctx *exec_ctx, diff --git a/src/core/lib/security/json_token.c b/src/core/lib/security/json_token.c index 372e5bfc5a..97054286d9 100644 --- a/src/core/lib/security/json_token.c +++ b/src/core/lib/security/json_token.c @@ -31,7 +31,7 @@ * */ -#include "src/core/security/json_token.h" +#include "src/core/lib/security/json_token.h" #include @@ -39,8 +39,8 @@ #include #include -#include "src/core/security/b64.h" -#include "src/core/support/string.h" +#include "src/core/lib/security/b64.h" +#include "src/core/lib/support/string.h" #include #include diff --git a/src/core/lib/security/json_token.h b/src/core/lib/security/json_token.h index 08ed4bfef3..376fb03875 100644 --- a/src/core/lib/security/json_token.h +++ b/src/core/lib/security/json_token.h @@ -37,7 +37,7 @@ #include #include -#include "src/core/json/json.h" +#include "src/core/lib/json/json.h" /* --- Constants. --- */ diff --git a/src/core/lib/security/jwt_verifier.c b/src/core/lib/security/jwt_verifier.c index 0bb8e05306..460b92f9a0 100644 --- a/src/core/lib/security/jwt_verifier.c +++ b/src/core/lib/security/jwt_verifier.c @@ -31,14 +31,14 @@ * */ -#include "src/core/security/jwt_verifier.h" +#include "src/core/lib/security/jwt_verifier.h" #include #include -#include "src/core/http/httpcli.h" -#include "src/core/security/b64.h" -#include "src/core/tsi/ssl_types.h" +#include "src/core/lib/http/httpcli.h" +#include "src/core/lib/security/b64.h" +#include "src/core/lib/tsi/ssl_types.h" #include #include diff --git a/src/core/lib/security/jwt_verifier.h b/src/core/lib/security/jwt_verifier.h index 7db7e6d7b4..28a9eff048 100644 --- a/src/core/lib/security/jwt_verifier.h +++ b/src/core/lib/security/jwt_verifier.h @@ -34,8 +34,8 @@ #ifndef GRPC_CORE_LIB_SECURITY_JWT_VERIFIER_H #define GRPC_CORE_LIB_SECURITY_JWT_VERIFIER_H -#include "src/core/iomgr/pollset.h" -#include "src/core/json/json.h" +#include "src/core/lib/iomgr/pollset.h" +#include "src/core/lib/json/json.h" #include #include diff --git a/src/core/lib/security/secure_endpoint.c b/src/core/lib/security/secure_endpoint.c index 58b081dc4a..e233b081ef 100644 --- a/src/core/lib/security/secure_endpoint.c +++ b/src/core/lib/security/secure_endpoint.c @@ -31,15 +31,15 @@ * */ -#include "src/core/security/secure_endpoint.h" +#include "src/core/lib/security/secure_endpoint.h" #include #include #include #include #include -#include "src/core/debug/trace.h" -#include "src/core/support/string.h" -#include "src/core/tsi/transport_security_interface.h" +#include "src/core/lib/debug/trace.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/tsi/transport_security_interface.h" #define STAGING_BUFFER_SIZE 8192 diff --git a/src/core/lib/security/secure_endpoint.h b/src/core/lib/security/secure_endpoint.h index f13a4cca44..57bd160a52 100644 --- a/src/core/lib/security/secure_endpoint.h +++ b/src/core/lib/security/secure_endpoint.h @@ -35,7 +35,7 @@ #define GRPC_CORE_LIB_SECURITY_SECURE_ENDPOINT_H #include -#include "src/core/iomgr/endpoint.h" +#include "src/core/lib/iomgr/endpoint.h" struct tsi_frame_protector; diff --git a/src/core/lib/security/security_connector.c b/src/core/lib/security/security_connector.c index fbec263eed..5474bc3a9e 100644 --- a/src/core/lib/security/security_connector.c +++ b/src/core/lib/security/security_connector.c @@ -31,7 +31,7 @@ * */ -#include "src/core/security/security_connector.h" +#include "src/core/lib/security/security_connector.h" #include #include @@ -42,16 +42,16 @@ #include #include -#include "src/core/security/credentials.h" -#include "src/core/security/handshake.h" -#include "src/core/security/secure_endpoint.h" -#include "src/core/security/security_context.h" -#include "src/core/support/env.h" -#include "src/core/support/load_file.h" -#include "src/core/support/string.h" -#include "src/core/transport/chttp2/alpn.h" -#include "src/core/tsi/fake_transport_security.h" -#include "src/core/tsi/ssl_transport_security.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/security/handshake.h" +#include "src/core/lib/security/secure_endpoint.h" +#include "src/core/lib/security/security_context.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/support/load_file.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/transport/chttp2/alpn.h" +#include "src/core/lib/tsi/fake_transport_security.h" +#include "src/core/lib/tsi/ssl_transport_security.h" /* -- Constants. -- */ diff --git a/src/core/lib/security/security_connector.h b/src/core/lib/security/security_connector.h index 2818299235..d50091c628 100644 --- a/src/core/lib/security/security_connector.h +++ b/src/core/lib/security/security_connector.h @@ -35,9 +35,9 @@ #define GRPC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_H #include -#include "src/core/iomgr/endpoint.h" -#include "src/core/iomgr/tcp_server.h" -#include "src/core/tsi/transport_security_interface.h" +#include "src/core/lib/iomgr/endpoint.h" +#include "src/core/lib/iomgr/tcp_server.h" +#include "src/core/lib/tsi/transport_security_interface.h" /* --- status enum. --- */ diff --git a/src/core/lib/security/security_context.c b/src/core/lib/security/security_context.c index f6afc0f633..0e66373bd8 100644 --- a/src/core/lib/security/security_context.c +++ b/src/core/lib/security/security_context.c @@ -33,10 +33,10 @@ #include -#include "src/core/security/security_context.h" -#include "src/core/support/string.h" -#include "src/core/surface/api_trace.h" -#include "src/core/surface/call.h" +#include "src/core/lib/security/security_context.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/call.h" #include #include diff --git a/src/core/lib/security/security_context.h b/src/core/lib/security/security_context.h index e205229081..e9e4e503bc 100644 --- a/src/core/lib/security/security_context.h +++ b/src/core/lib/security/security_context.h @@ -34,8 +34,8 @@ #ifndef GRPC_CORE_LIB_SECURITY_SECURITY_CONTEXT_H #define GRPC_CORE_LIB_SECURITY_SECURITY_CONTEXT_H -#include "src/core/iomgr/pollset.h" -#include "src/core/security/credentials.h" +#include "src/core/lib/iomgr/pollset.h" +#include "src/core/lib/security/credentials.h" /* --- grpc_auth_context --- diff --git a/src/core/lib/security/server_auth_filter.c b/src/core/lib/security/server_auth_filter.c index f3c411d6d4..158cde0e2c 100644 --- a/src/core/lib/security/server_auth_filter.c +++ b/src/core/lib/security/server_auth_filter.c @@ -33,9 +33,9 @@ #include -#include "src/core/security/auth_filters.h" -#include "src/core/security/credentials.h" -#include "src/core/security/security_context.h" +#include "src/core/lib/security/auth_filters.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/security/security_context.h" #include #include diff --git a/src/core/lib/security/server_secure_chttp2.c b/src/core/lib/security/server_secure_chttp2.c index da29ca934b..7c9dd221ed 100644 --- a/src/core/lib/security/server_secure_chttp2.c +++ b/src/core/lib/security/server_secure_chttp2.c @@ -39,18 +39,18 @@ #include #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/iomgr/endpoint.h" -#include "src/core/iomgr/resolve_address.h" -#include "src/core/iomgr/tcp_server.h" -#include "src/core/security/auth_filters.h" -#include "src/core/security/credentials.h" -#include "src/core/security/security_connector.h" -#include "src/core/security/security_context.h" -#include "src/core/surface/api_trace.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/iomgr/endpoint.h" +#include "src/core/lib/iomgr/resolve_address.h" +#include "src/core/lib/iomgr/tcp_server.h" +#include "src/core/lib/security/auth_filters.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/security/security_connector.h" +#include "src/core/lib/security/security_context.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" typedef struct grpc_server_secure_state { grpc_server *server; diff --git a/src/core/lib/statistics/census_init.c b/src/core/lib/statistics/census_init.c index b6a962f228..bbecd62764 100644 --- a/src/core/lib/statistics/census_init.c +++ b/src/core/lib/statistics/census_init.c @@ -31,11 +31,11 @@ * */ -#include "src/core/statistics/census_interface.h" +#include "src/core/lib/statistics/census_interface.h" #include -#include "src/core/statistics/census_rpc_stats.h" -#include "src/core/statistics/census_tracing.h" +#include "src/core/lib/statistics/census_rpc_stats.h" +#include "src/core/lib/statistics/census_tracing.h" void census_init(void) { census_tracing_init(); diff --git a/src/core/lib/statistics/census_log.c b/src/core/lib/statistics/census_log.c index 3802d1cc7a..1fb942a78a 100644 --- a/src/core/lib/statistics/census_log.c +++ b/src/core/lib/statistics/census_log.c @@ -89,7 +89,7 @@ include the name of the structure, which will be passed as the first argument. E.g. cl_block_initialize() will initialize a cl_block. */ -#include "src/core/statistics/census_log.h" +#include "src/core/lib/statistics/census_log.h" #include #include #include diff --git a/src/core/lib/statistics/census_rpc_stats.c b/src/core/lib/statistics/census_rpc_stats.c index c78d6fd612..2182561668 100644 --- a/src/core/lib/statistics/census_rpc_stats.c +++ b/src/core/lib/statistics/census_rpc_stats.c @@ -36,13 +36,13 @@ #include #include #include -#include "src/core/statistics/census_interface.h" -#include "src/core/statistics/census_rpc_stats.h" -#include "src/core/statistics/census_tracing.h" -#include "src/core/statistics/hash_table.h" -#include "src/core/statistics/window_stats.h" -#include "src/core/support/murmur_hash.h" -#include "src/core/support/string.h" +#include "src/core/lib/statistics/census_interface.h" +#include "src/core/lib/statistics/census_rpc_stats.h" +#include "src/core/lib/statistics/census_tracing.h" +#include "src/core/lib/statistics/hash_table.h" +#include "src/core/lib/statistics/window_stats.h" +#include "src/core/lib/support/murmur_hash.h" +#include "src/core/lib/support/string.h" #define NUM_INTERVALS 3 #define MINUTE_INTERVAL 0 diff --git a/src/core/lib/statistics/census_rpc_stats.h b/src/core/lib/statistics/census_rpc_stats.h index 1b45872be8..00bb48205e 100644 --- a/src/core/lib/statistics/census_rpc_stats.h +++ b/src/core/lib/statistics/census_rpc_stats.h @@ -35,7 +35,7 @@ #define GRPC_CORE_LIB_STATISTICS_CENSUS_RPC_STATS_H #include -#include "src/core/statistics/census_interface.h" +#include "src/core/lib/statistics/census_interface.h" #ifdef __cplusplus extern "C" { diff --git a/src/core/lib/statistics/census_tracing.c b/src/core/lib/statistics/census_tracing.c index ad82498eba..b58ae733fc 100644 --- a/src/core/lib/statistics/census_tracing.c +++ b/src/core/lib/statistics/census_tracing.c @@ -31,8 +31,8 @@ * */ -#include "src/core/statistics/census_tracing.h" -#include "src/core/statistics/census_interface.h" +#include "src/core/lib/statistics/census_tracing.h" +#include "src/core/lib/statistics/census_interface.h" #include #include @@ -41,8 +41,8 @@ #include #include #include -#include "src/core/statistics/hash_table.h" -#include "src/core/support/string.h" +#include "src/core/lib/statistics/hash_table.h" +#include "src/core/lib/support/string.h" void census_trace_obj_destroy(census_trace_obj *obj) { census_trace_annotation *p = obj->annotations; diff --git a/src/core/lib/statistics/census_tracing.h b/src/core/lib/statistics/census_tracing.h index e497bc354d..a101abf3cb 100644 --- a/src/core/lib/statistics/census_tracing.h +++ b/src/core/lib/statistics/census_tracing.h @@ -35,7 +35,7 @@ #define GRPC_CORE_LIB_STATISTICS_CENSUS_TRACING_H #include -#include "src/core/statistics/census_rpc_stats.h" +#include "src/core/lib/statistics/census_rpc_stats.h" /* WARNING: The data structures and APIs provided by this file are for GRPC library's internal use ONLY. They might be changed in backward-incompatible diff --git a/src/core/lib/statistics/hash_table.c b/src/core/lib/statistics/hash_table.c index 3ef79c0d7d..18b7442a0c 100644 --- a/src/core/lib/statistics/hash_table.c +++ b/src/core/lib/statistics/hash_table.c @@ -31,7 +31,7 @@ * */ -#include "src/core/statistics/hash_table.h" +#include "src/core/lib/statistics/hash_table.h" #include #include diff --git a/src/core/lib/statistics/window_stats.c b/src/core/lib/statistics/window_stats.c index eb296865a0..53427a24bc 100644 --- a/src/core/lib/statistics/window_stats.c +++ b/src/core/lib/statistics/window_stats.c @@ -31,7 +31,7 @@ * */ -#include "src/core/statistics/window_stats.h" +#include "src/core/lib/statistics/window_stats.h" #include #include #include diff --git a/src/core/lib/support/alloc.c b/src/core/lib/support/alloc.c index fd9fb8f5e7..27fa6a95ed 100644 --- a/src/core/lib/support/alloc.c +++ b/src/core/lib/support/alloc.c @@ -36,7 +36,7 @@ #include #include #include -#include "src/core/profiling/timers.h" +#include "src/core/lib/profiling/timers.h" static gpr_allocation_functions g_alloc_functions = {malloc, realloc, free}; diff --git a/src/core/lib/support/backoff.c b/src/core/lib/support/backoff.c index 4ccfb774ed..e89ef47220 100644 --- a/src/core/lib/support/backoff.c +++ b/src/core/lib/support/backoff.c @@ -31,7 +31,7 @@ * */ -#include "src/core/support/backoff.h" +#include "src/core/lib/support/backoff.h" #include diff --git a/src/core/lib/support/cmdline.c b/src/core/lib/support/cmdline.c index eff46a1655..35c4990b22 100644 --- a/src/core/lib/support/cmdline.c +++ b/src/core/lib/support/cmdline.c @@ -40,7 +40,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" typedef enum { ARGTYPE_INT, ARGTYPE_BOOL, ARGTYPE_STRING } argtype; diff --git a/src/core/lib/support/env_linux.c b/src/core/lib/support/env_linux.c index fe51f846b7..a86133e6c3 100644 --- a/src/core/lib/support/env_linux.c +++ b/src/core/lib/support/env_linux.c @@ -40,7 +40,7 @@ #ifdef GPR_LINUX_ENV -#include "src/core/support/env.h" +#include "src/core/lib/support/env.h" #include #include @@ -51,7 +51,7 @@ #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" char *gpr_getenv(const char *name) { #if defined(GPR_BACKWARDS_COMPATIBILITY_MODE) diff --git a/src/core/lib/support/env_posix.c b/src/core/lib/support/env_posix.c index 256212be76..1b57b094a9 100644 --- a/src/core/lib/support/env_posix.c +++ b/src/core/lib/support/env_posix.c @@ -35,14 +35,14 @@ #ifdef GPR_POSIX_ENV -#include "src/core/support/env.h" +#include "src/core/lib/support/env.h" #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" char *gpr_getenv(const char *name) { char *result = getenv(name); diff --git a/src/core/lib/support/env_win32.c b/src/core/lib/support/env_win32.c index 10258283ba..566feee49e 100644 --- a/src/core/lib/support/env_win32.c +++ b/src/core/lib/support/env_win32.c @@ -35,8 +35,8 @@ #ifdef GPR_WIN32 -#include "src/core/support/env.h" -#include "src/core/support/string.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/support/string.h" #ifdef __MINGW32__ errno_t getenv_s(size_t *size_needed, char *buffer, size_t size, diff --git a/src/core/lib/support/host_port.c b/src/core/lib/support/host_port.c index 31243a7221..e03f6241ff 100644 --- a/src/core/lib/support/host_port.c +++ b/src/core/lib/support/host_port.c @@ -38,7 +38,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" int gpr_join_host_port(char **out, const char *host, int port) { if (host[0] != '[' && strchr(host, ':') != NULL) { diff --git a/src/core/lib/support/load_file.c b/src/core/lib/support/load_file.c index 650bd62ccb..0cecd5edd5 100644 --- a/src/core/lib/support/load_file.c +++ b/src/core/lib/support/load_file.c @@ -31,7 +31,7 @@ * */ -#include "src/core/support/load_file.h" +#include "src/core/lib/support/load_file.h" #include #include @@ -40,8 +40,8 @@ #include #include -#include "src/core/support/block_annotate.h" -#include "src/core/support/string.h" +#include "src/core/lib/support/block_annotate.h" +#include "src/core/lib/support/string.h" gpr_slice gpr_load_file(const char *filename, int add_null_terminator, int *success) { diff --git a/src/core/lib/support/log_win32.c b/src/core/lib/support/log_win32.c index 89ec0917d5..cec99440a5 100644 --- a/src/core/lib/support/log_win32.c +++ b/src/core/lib/support/log_win32.c @@ -44,8 +44,8 @@ #include #include -#include "src/core/support/string.h" -#include "src/core/support/string_win32.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/support/string_win32.h" void gpr_log(const char *file, int line, gpr_log_severity severity, const char *format, ...) { diff --git a/src/core/lib/support/murmur_hash.c b/src/core/lib/support/murmur_hash.c index 47e9777fec..97832f1510 100644 --- a/src/core/lib/support/murmur_hash.c +++ b/src/core/lib/support/murmur_hash.c @@ -31,7 +31,7 @@ * */ -#include "src/core/support/murmur_hash.h" +#include "src/core/lib/support/murmur_hash.h" #define ROTL32(x, r) ((x) << (r)) | ((x) >> (32 - (r))) diff --git a/src/core/lib/support/stack_lockfree.c b/src/core/lib/support/stack_lockfree.c index 8e0bbfaee8..de80486132 100644 --- a/src/core/lib/support/stack_lockfree.c +++ b/src/core/lib/support/stack_lockfree.c @@ -31,7 +31,7 @@ * */ -#include "src/core/support/stack_lockfree.h" +#include "src/core/lib/support/stack_lockfree.h" #include #include diff --git a/src/core/lib/support/string.c b/src/core/lib/support/string.c index e8021ddaba..365d861de3 100644 --- a/src/core/lib/support/string.c +++ b/src/core/lib/support/string.c @@ -31,7 +31,7 @@ * */ -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include #include diff --git a/src/core/lib/support/string_win32.c b/src/core/lib/support/string_win32.c index 0780907994..16b7e37f2a 100644 --- a/src/core/lib/support/string_win32.c +++ b/src/core/lib/support/string_win32.c @@ -43,7 +43,7 @@ #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" int gpr_asprintf(char **strp, const char *format, ...) { va_list args; diff --git a/src/core/lib/support/subprocess_windows.c b/src/core/lib/support/subprocess_windows.c index 6afbefeb2b..264306f1bd 100644 --- a/src/core/lib/support/subprocess_windows.c +++ b/src/core/lib/support/subprocess_windows.c @@ -42,8 +42,8 @@ #include #include #include -#include "src/core/support/string.h" -#include "src/core/support/string_win32.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/support/string_win32.h" struct gpr_subprocess { PROCESS_INFORMATION pi; diff --git a/src/core/lib/support/sync_posix.c b/src/core/lib/support/sync_posix.c index be4d0ac1c9..a5e59db8c7 100644 --- a/src/core/lib/support/sync_posix.c +++ b/src/core/lib/support/sync_posix.c @@ -40,7 +40,7 @@ #include #include #include -#include "src/core/profiling/timers.h" +#include "src/core/lib/profiling/timers.h" void gpr_mu_init(gpr_mu* mu) { GPR_ASSERT(pthread_mutex_init(mu, NULL) == 0); } diff --git a/src/core/lib/support/time_posix.c b/src/core/lib/support/time_posix.c index f999e08cb0..6435af6340 100644 --- a/src/core/lib/support/time_posix.c +++ b/src/core/lib/support/time_posix.c @@ -44,7 +44,7 @@ #endif #include #include -#include "src/core/support/block_annotate.h" +#include "src/core/lib/support/block_annotate.h" static struct timespec timespec_from_gpr(gpr_timespec gts) { struct timespec rv; diff --git a/src/core/lib/support/time_win32.c b/src/core/lib/support/time_win32.c index 2c344d3f3b..4152f5db21 100644 --- a/src/core/lib/support/time_win32.c +++ b/src/core/lib/support/time_win32.c @@ -44,7 +44,7 @@ #include #include -#include "src/core/support/block_annotate.h" +#include "src/core/lib/support/block_annotate.h" static LARGE_INTEGER g_start_time; static double g_time_scale; diff --git a/src/core/lib/support/tmpfile_posix.c b/src/core/lib/support/tmpfile_posix.c index b16eeacf9d..743f45e1bc 100644 --- a/src/core/lib/support/tmpfile_posix.c +++ b/src/core/lib/support/tmpfile_posix.c @@ -35,7 +35,7 @@ #ifdef GPR_POSIX_FILE -#include "src/core/support/tmpfile.h" +#include "src/core/lib/support/tmpfile.h" #include #include @@ -46,7 +46,7 @@ #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" FILE *gpr_tmpfile(const char *prefix, char **tmp_filename) { FILE *result = NULL; diff --git a/src/core/lib/support/tmpfile_win32.c b/src/core/lib/support/tmpfile_win32.c index 3000f0029f..05d92b6036 100644 --- a/src/core/lib/support/tmpfile_win32.c +++ b/src/core/lib/support/tmpfile_win32.c @@ -44,8 +44,8 @@ #include #include -#include "src/core/support/string_win32.h" -#include "src/core/support/tmpfile.h" +#include "src/core/lib/support/string_win32.h" +#include "src/core/lib/support/tmpfile.h" FILE *gpr_tmpfile(const char *prefix, char **tmp_filename_out) { FILE *result = NULL; diff --git a/src/core/lib/surface/alarm.c b/src/core/lib/surface/alarm.c index 1085285f95..368683378e 100644 --- a/src/core/lib/surface/alarm.c +++ b/src/core/lib/surface/alarm.c @@ -33,8 +33,8 @@ #include #include -#include "src/core/iomgr/timer.h" -#include "src/core/surface/completion_queue.h" +#include "src/core/lib/iomgr/timer.h" +#include "src/core/lib/surface/completion_queue.h" struct grpc_alarm { grpc_timer alarm; diff --git a/src/core/lib/surface/api_trace.c b/src/core/lib/surface/api_trace.c index 06c65c0610..3702c024db 100644 --- a/src/core/lib/surface/api_trace.c +++ b/src/core/lib/surface/api_trace.c @@ -31,6 +31,6 @@ * */ -#include "src/core/surface/api_trace.h" +#include "src/core/lib/surface/api_trace.h" int grpc_api_trace = 0; diff --git a/src/core/lib/surface/api_trace.h b/src/core/lib/surface/api_trace.h index 00d71677e5..b50011c9e5 100644 --- a/src/core/lib/surface/api_trace.h +++ b/src/core/lib/surface/api_trace.h @@ -35,7 +35,7 @@ #define GRPC_CORE_LIB_SURFACE_API_TRACE_H #include -#include "src/core/debug/trace.h" +#include "src/core/lib/debug/trace.h" extern int grpc_api_trace; diff --git a/src/core/lib/surface/byte_buffer_reader.c b/src/core/lib/surface/byte_buffer_reader.c index 4a418faaed..7248f5fe71 100644 --- a/src/core/lib/surface/byte_buffer_reader.c +++ b/src/core/lib/surface/byte_buffer_reader.c @@ -41,7 +41,7 @@ #include #include -#include "src/core/compression/message_compress.h" +#include "src/core/lib/compression/message_compress.h" static int is_compressed(grpc_byte_buffer *buffer) { switch (buffer->type) { diff --git a/src/core/lib/surface/call.c b/src/core/lib/surface/call.c index 6f1cd1df10..d63a4a7401 100644 --- a/src/core/lib/surface/call.c +++ b/src/core/lib/surface/call.c @@ -43,16 +43,16 @@ #include #include -#include "src/core/channel/channel_stack.h" -#include "src/core/compression/algorithm_metadata.h" -#include "src/core/iomgr/timer.h" -#include "src/core/profiling/timers.h" -#include "src/core/support/string.h" -#include "src/core/surface/api_trace.h" -#include "src/core/surface/call.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/completion_queue.h" -#include "src/core/transport/static_metadata.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/compression/algorithm_metadata.h" +#include "src/core/lib/iomgr/timer.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/call.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/completion_queue.h" +#include "src/core/lib/transport/static_metadata.h" /** The maximum number of concurrent batches possible. Based upon the maximum number of individually queueable ops in the batch diff --git a/src/core/lib/surface/call.h b/src/core/lib/surface/call.h index 09e19dc779..e2e75865be 100644 --- a/src/core/lib/surface/call.h +++ b/src/core/lib/surface/call.h @@ -34,10 +34,10 @@ #ifndef GRPC_CORE_LIB_SURFACE_CALL_H #define GRPC_CORE_LIB_SURFACE_CALL_H -#include "src/core/channel/channel_stack.h" -#include "src/core/channel/context.h" -#include "src/core/surface/api_trace.h" -#include "src/core/surface/surface_trace.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/channel/context.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/surface_trace.h" #include #include diff --git a/src/core/lib/surface/call_details.c b/src/core/lib/surface/call_details.c index dc5ea22ee7..08f606d84a 100644 --- a/src/core/lib/surface/call_details.c +++ b/src/core/lib/surface/call_details.c @@ -36,7 +36,7 @@ #include -#include "src/core/surface/api_trace.h" +#include "src/core/lib/surface/api_trace.h" void grpc_call_details_init(grpc_call_details* cd) { GRPC_API_TRACE("grpc_call_details_init(cd=%p)", 1, (cd)); diff --git a/src/core/lib/surface/call_log_batch.c b/src/core/lib/surface/call_log_batch.c index 044211616c..bc5a2ffb65 100644 --- a/src/core/lib/surface/call_log_batch.c +++ b/src/core/lib/surface/call_log_batch.c @@ -31,11 +31,11 @@ * */ -#include "src/core/surface/call.h" +#include "src/core/lib/surface/call.h" #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" static void add_metadata(gpr_strvec *b, const grpc_metadata *md, size_t count) { size_t i; diff --git a/src/core/lib/surface/channel.c b/src/core/lib/surface/channel.c index 0010b64c7d..d815daa70c 100644 --- a/src/core/lib/surface/channel.c +++ b/src/core/lib/surface/channel.c @@ -31,7 +31,7 @@ * */ -#include "src/core/surface/channel.h" +#include "src/core/lib/surface/channel.h" #include #include @@ -40,14 +40,14 @@ #include #include -#include "src/core/client_config/resolver_registry.h" -#include "src/core/iomgr/iomgr.h" -#include "src/core/support/string.h" -#include "src/core/surface/api_trace.h" -#include "src/core/surface/call.h" -#include "src/core/surface/channel_init.h" -#include "src/core/surface/init.h" -#include "src/core/transport/static_metadata.h" +#include "src/core/lib/client_config/resolver_registry.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/call.h" +#include "src/core/lib/surface/channel_init.h" +#include "src/core/lib/surface/init.h" +#include "src/core/lib/transport/static_metadata.h" /** Cache grpc-status: X mdelems for X = 0..NUM_CACHED_STATUS_ELEMS. * Avoids needing to take a metadata context lock for sending status diff --git a/src/core/lib/surface/channel.h b/src/core/lib/surface/channel.h index d0e15bbeb8..09de0fccc9 100644 --- a/src/core/lib/surface/channel.h +++ b/src/core/lib/surface/channel.h @@ -34,9 +34,9 @@ #ifndef GRPC_CORE_LIB_SURFACE_CHANNEL_H #define GRPC_CORE_LIB_SURFACE_CHANNEL_H -#include "src/core/channel/channel_stack.h" -#include "src/core/client_config/subchannel_factory.h" -#include "src/core/surface/channel_stack_type.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/client_config/subchannel_factory.h" +#include "src/core/lib/surface/channel_stack_type.h" grpc_channel *grpc_channel_create(grpc_exec_ctx *exec_ctx, const char *target, const grpc_channel_args *args, diff --git a/src/core/lib/surface/channel_connectivity.c b/src/core/lib/surface/channel_connectivity.c index 18267939ed..2f5d763e70 100644 --- a/src/core/lib/surface/channel_connectivity.c +++ b/src/core/lib/surface/channel_connectivity.c @@ -31,15 +31,15 @@ * */ -#include "src/core/surface/channel.h" +#include "src/core/lib/surface/channel.h" #include #include -#include "src/core/channel/client_channel.h" -#include "src/core/iomgr/timer.h" -#include "src/core/surface/api_trace.h" -#include "src/core/surface/completion_queue.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/iomgr/timer.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/completion_queue.h" grpc_connectivity_state grpc_channel_check_connectivity_state( grpc_channel *channel, int try_to_connect) { diff --git a/src/core/lib/surface/channel_create.c b/src/core/lib/surface/channel_create.c index 123447c8ed..e8777ce816 100644 --- a/src/core/lib/surface/channel_create.c +++ b/src/core/lib/surface/channel_create.c @@ -40,16 +40,16 @@ #include #include -#include "src/core/census/grpc_filter.h" -#include "src/core/channel/channel_args.h" -#include "src/core/channel/client_channel.h" -#include "src/core/channel/compress_filter.h" -#include "src/core/channel/http_client_filter.h" -#include "src/core/client_config/resolver_registry.h" -#include "src/core/iomgr/tcp_client.h" -#include "src/core/surface/api_trace.h" -#include "src/core/surface/channel.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/census/grpc_filter.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/compress_filter.h" +#include "src/core/lib/channel/http_client_filter.h" +#include "src/core/lib/client_config/resolver_registry.h" +#include "src/core/lib/iomgr/tcp_client.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/transport/chttp2_transport.h" typedef struct { grpc_connector base; diff --git a/src/core/lib/surface/channel_init.c b/src/core/lib/surface/channel_init.c index ac962f3972..fc69f61f77 100644 --- a/src/core/lib/surface/channel_init.c +++ b/src/core/lib/surface/channel_init.c @@ -31,7 +31,7 @@ * */ -#include "src/core/surface/channel_init.h" +#include "src/core/lib/surface/channel_init.h" #include #include diff --git a/src/core/lib/surface/channel_init.h b/src/core/lib/surface/channel_init.h index ef994b940f..a4d8271ca6 100644 --- a/src/core/lib/surface/channel_init.h +++ b/src/core/lib/surface/channel_init.h @@ -34,9 +34,9 @@ #ifndef GRPC_CORE_LIB_SURFACE_CHANNEL_INIT_H #define GRPC_CORE_LIB_SURFACE_CHANNEL_INIT_H -#include "src/core/channel/channel_stack_builder.h" -#include "src/core/surface/channel_stack_type.h" -#include "src/core/transport/transport.h" +#include "src/core/lib/channel/channel_stack_builder.h" +#include "src/core/lib/surface/channel_stack_type.h" +#include "src/core/lib/transport/transport.h" /// This module provides a way for plugins (and the grpc core library itself) /// to register mutators for channel stacks. diff --git a/src/core/lib/surface/channel_ping.c b/src/core/lib/surface/channel_ping.c index 983f1c8a66..dd862cdadd 100644 --- a/src/core/lib/surface/channel_ping.c +++ b/src/core/lib/surface/channel_ping.c @@ -31,15 +31,15 @@ * */ -#include "src/core/surface/channel.h" +#include "src/core/lib/surface/channel.h" #include #include #include -#include "src/core/surface/api_trace.h" -#include "src/core/surface/completion_queue.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/completion_queue.h" typedef struct { grpc_closure closure; diff --git a/src/core/lib/surface/channel_stack_type.c b/src/core/lib/surface/channel_stack_type.c index 1a6e949ffe..c35d603ca3 100644 --- a/src/core/lib/surface/channel_stack_type.c +++ b/src/core/lib/surface/channel_stack_type.c @@ -31,7 +31,7 @@ * */ -#include "src/core/surface/channel_stack_type.h" +#include "src/core/lib/surface/channel_stack_type.h" #include #include diff --git a/src/core/lib/surface/completion_queue.c b/src/core/lib/surface/completion_queue.c index b22818ea87..a0d7002053 100644 --- a/src/core/lib/surface/completion_queue.c +++ b/src/core/lib/surface/completion_queue.c @@ -31,7 +31,7 @@ * */ -#include "src/core/surface/completion_queue.h" +#include "src/core/lib/surface/completion_queue.h" #include #include @@ -41,14 +41,14 @@ #include #include -#include "src/core/iomgr/pollset.h" -#include "src/core/iomgr/timer.h" -#include "src/core/profiling/timers.h" -#include "src/core/support/string.h" -#include "src/core/surface/api_trace.h" -#include "src/core/surface/call.h" -#include "src/core/surface/event_string.h" -#include "src/core/surface/surface_trace.h" +#include "src/core/lib/iomgr/pollset.h" +#include "src/core/lib/iomgr/timer.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/call.h" +#include "src/core/lib/surface/event_string.h" +#include "src/core/lib/surface/surface_trace.h" typedef struct { grpc_pollset_worker **worker; diff --git a/src/core/lib/surface/completion_queue.h b/src/core/lib/surface/completion_queue.h index 08c07f3baa..35591cb6f4 100644 --- a/src/core/lib/surface/completion_queue.h +++ b/src/core/lib/surface/completion_queue.h @@ -37,7 +37,7 @@ /* Internal API for completion queues */ #include -#include "src/core/iomgr/pollset.h" +#include "src/core/lib/iomgr/pollset.h" typedef struct grpc_cq_completion { /** user supplied tag */ diff --git a/src/core/lib/surface/event_string.c b/src/core/lib/surface/event_string.c index 85a372b9ad..360c718a17 100644 --- a/src/core/lib/surface/event_string.c +++ b/src/core/lib/surface/event_string.c @@ -31,13 +31,13 @@ * */ -#include "src/core/surface/event_string.h" +#include "src/core/lib/surface/event_string.h" #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" static void addhdr(gpr_strvec *buf, grpc_event *ev) { char *tmp; diff --git a/src/core/lib/surface/init.c b/src/core/lib/surface/init.c index 3c4db3e6cc..dcb9c62d36 100644 --- a/src/core/lib/surface/init.c +++ b/src/core/lib/surface/init.c @@ -40,36 +40,36 @@ #include #include /* TODO(ctiller): find another way? - better not to include census here */ -#include "src/core/census/grpc_plugin.h" -#include "src/core/channel/channel_stack.h" -#include "src/core/channel/client_channel.h" -#include "src/core/channel/compress_filter.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/http_client_filter.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/client_config/lb_policies/pick_first.h" -#include "src/core/client_config/lb_policies/round_robin.h" -#include "src/core/client_config/lb_policy_registry.h" -#include "src/core/client_config/resolver_registry.h" -#include "src/core/client_config/resolvers/dns_resolver.h" -#include "src/core/client_config/resolvers/sockaddr_resolver.h" -#include "src/core/client_config/subchannel.h" -#include "src/core/client_config/subchannel_index.h" -#include "src/core/debug/trace.h" -#include "src/core/iomgr/executor.h" -#include "src/core/iomgr/iomgr.h" -#include "src/core/profiling/timers.h" -#include "src/core/surface/api_trace.h" -#include "src/core/surface/call.h" -#include "src/core/surface/channel_init.h" -#include "src/core/surface/completion_queue.h" -#include "src/core/surface/init.h" -#include "src/core/surface/lame_client.h" -#include "src/core/surface/server.h" -#include "src/core/surface/surface_trace.h" -#include "src/core/transport/chttp2_transport.h" -#include "src/core/transport/connectivity_state.h" -#include "src/core/transport/transport_impl.h" +#include "src/core/lib/census/grpc_plugin.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/compress_filter.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/http_client_filter.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/client_config/lb_policies/pick_first.h" +#include "src/core/lib/client_config/lb_policies/round_robin.h" +#include "src/core/lib/client_config/lb_policy_registry.h" +#include "src/core/lib/client_config/resolver_registry.h" +#include "src/core/lib/client_config/resolvers/dns_resolver.h" +#include "src/core/lib/client_config/resolvers/sockaddr_resolver.h" +#include "src/core/lib/client_config/subchannel.h" +#include "src/core/lib/client_config/subchannel_index.h" +#include "src/core/lib/debug/trace.h" +#include "src/core/lib/iomgr/executor.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/call.h" +#include "src/core/lib/surface/channel_init.h" +#include "src/core/lib/surface/completion_queue.h" +#include "src/core/lib/surface/init.h" +#include "src/core/lib/surface/lame_client.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/surface/surface_trace.h" +#include "src/core/lib/transport/chttp2_transport.h" +#include "src/core/lib/transport/connectivity_state.h" +#include "src/core/lib/transport/transport_impl.h" #ifndef GRPC_DEFAULT_NAME_PREFIX #define GRPC_DEFAULT_NAME_PREFIX "dns:///" diff --git a/src/core/lib/surface/init_secure.c b/src/core/lib/surface/init_secure.c index e0d66a8d46..d3c2f645a7 100644 --- a/src/core/lib/surface/init_secure.c +++ b/src/core/lib/surface/init_secure.c @@ -31,18 +31,18 @@ * */ -#include "src/core/surface/init.h" +#include "src/core/lib/surface/init.h" #include #include -#include "src/core/debug/trace.h" -#include "src/core/security/auth_filters.h" -#include "src/core/security/credentials.h" -#include "src/core/security/secure_endpoint.h" -#include "src/core/security/security_connector.h" -#include "src/core/surface/channel_init.h" -#include "src/core/tsi/transport_security_interface.h" +#include "src/core/lib/debug/trace.h" +#include "src/core/lib/security/auth_filters.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/security/secure_endpoint.h" +#include "src/core/lib/security/security_connector.h" +#include "src/core/lib/surface/channel_init.h" +#include "src/core/lib/tsi/transport_security_interface.h" void grpc_security_pre_init(void) { grpc_register_tracer("secure_endpoint", &grpc_trace_secure_endpoint); diff --git a/src/core/lib/surface/init_unsecure.c b/src/core/lib/surface/init_unsecure.c index 278fcc83ac..243c005d86 100644 --- a/src/core/lib/surface/init_unsecure.c +++ b/src/core/lib/surface/init_unsecure.c @@ -31,7 +31,7 @@ * */ -#include "src/core/surface/init.h" +#include "src/core/lib/surface/init.h" void grpc_security_pre_init(void) {} diff --git a/src/core/lib/surface/lame_client.c b/src/core/lib/surface/lame_client.c index 25f3a74349..95ec4b06c3 100644 --- a/src/core/lib/surface/lame_client.c +++ b/src/core/lib/surface/lame_client.c @@ -31,7 +31,7 @@ * */ -#include "src/core/surface/lame_client.h" +#include "src/core/lib/surface/lame_client.h" #include @@ -39,11 +39,11 @@ #include #include -#include "src/core/channel/channel_stack.h" -#include "src/core/support/string.h" -#include "src/core/surface/api_trace.h" -#include "src/core/surface/call.h" -#include "src/core/surface/channel.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/call.h" +#include "src/core/lib/surface/channel.h" typedef struct { grpc_linked_mdelem status; diff --git a/src/core/lib/surface/lame_client.h b/src/core/lib/surface/lame_client.h index cee9500f3e..5f6ea34d4b 100644 --- a/src/core/lib/surface/lame_client.h +++ b/src/core/lib/surface/lame_client.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_SURFACE_LAME_CLIENT_H #define GRPC_CORE_LIB_SURFACE_LAME_CLIENT_H -#include "src/core/channel/channel_stack.h" +#include "src/core/lib/channel/channel_stack.h" extern const grpc_channel_filter grpc_lame_filter; diff --git a/src/core/lib/surface/metadata_array.c b/src/core/lib/surface/metadata_array.c index 57096326a3..4436f2da87 100644 --- a/src/core/lib/surface/metadata_array.c +++ b/src/core/lib/surface/metadata_array.c @@ -36,7 +36,7 @@ #include -#include "src/core/surface/api_trace.h" +#include "src/core/lib/surface/api_trace.h" void grpc_metadata_array_init(grpc_metadata_array* array) { GRPC_API_TRACE("grpc_metadata_array_init(array=%p)", 1, (array)); diff --git a/src/core/lib/surface/secure_channel_create.c b/src/core/lib/surface/secure_channel_create.c index cc752227ee..dcb367023e 100644 --- a/src/core/lib/surface/secure_channel_create.c +++ b/src/core/lib/surface/secure_channel_create.c @@ -40,17 +40,17 @@ #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/channel/client_channel.h" -#include "src/core/client_config/resolver_registry.h" -#include "src/core/iomgr/tcp_client.h" -#include "src/core/security/auth_filters.h" -#include "src/core/security/credentials.h" -#include "src/core/security/security_context.h" -#include "src/core/surface/api_trace.h" -#include "src/core/surface/channel.h" -#include "src/core/transport/chttp2_transport.h" -#include "src/core/tsi/transport_security_interface.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/client_config/resolver_registry.h" +#include "src/core/lib/iomgr/tcp_client.h" +#include "src/core/lib/security/auth_filters.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/security/security_context.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/transport/chttp2_transport.h" +#include "src/core/lib/tsi/transport_security_interface.h" typedef struct { grpc_connector base; diff --git a/src/core/lib/surface/server.c b/src/core/lib/surface/server.c index a92f2b3e38..080734e9d5 100644 --- a/src/core/lib/surface/server.c +++ b/src/core/lib/surface/server.c @@ -31,7 +31,7 @@ * */ -#include "src/core/surface/server.h" +#include "src/core/lib/surface/server.h" #include #include @@ -42,18 +42,18 @@ #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/iomgr/iomgr.h" -#include "src/core/support/stack_lockfree.h" -#include "src/core/support/string.h" -#include "src/core/surface/api_trace.h" -#include "src/core/surface/call.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/completion_queue.h" -#include "src/core/surface/init.h" -#include "src/core/transport/metadata.h" -#include "src/core/transport/static_metadata.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/support/stack_lockfree.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/call.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/completion_queue.h" +#include "src/core/lib/surface/init.h" +#include "src/core/lib/transport/metadata.h" +#include "src/core/lib/transport/static_metadata.h" typedef struct listener { void *arg; diff --git a/src/core/lib/surface/server.h b/src/core/lib/surface/server.h index 969d268053..3845eb2981 100644 --- a/src/core/lib/surface/server.h +++ b/src/core/lib/surface/server.h @@ -35,8 +35,8 @@ #define GRPC_CORE_LIB_SURFACE_SERVER_H #include -#include "src/core/channel/channel_stack.h" -#include "src/core/transport/transport.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/transport/transport.h" extern const grpc_channel_filter grpc_server_top_filter; diff --git a/src/core/lib/surface/server_chttp2.c b/src/core/lib/surface/server_chttp2.c index 546760ecfa..f0c2ee5153 100644 --- a/src/core/lib/surface/server_chttp2.c +++ b/src/core/lib/surface/server_chttp2.c @@ -36,12 +36,12 @@ #include #include #include -#include "src/core/channel/http_server_filter.h" -#include "src/core/iomgr/resolve_address.h" -#include "src/core/iomgr/tcp_server.h" -#include "src/core/surface/api_trace.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/iomgr/resolve_address.h" +#include "src/core/lib/iomgr/tcp_server.h" +#include "src/core/lib/surface/api_trace.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" static void setup_transport(grpc_exec_ctx *exec_ctx, void *server, grpc_transport *transport) { diff --git a/src/core/lib/surface/surface_trace.h b/src/core/lib/surface/surface_trace.h index 1046eb0c83..6b3f673924 100644 --- a/src/core/lib/surface/surface_trace.h +++ b/src/core/lib/surface/surface_trace.h @@ -35,8 +35,8 @@ #define GRPC_CORE_LIB_SURFACE_SURFACE_TRACE_H #include -#include "src/core/debug/trace.h" -#include "src/core/surface/api_trace.h" +#include "src/core/lib/debug/trace.h" +#include "src/core/lib/surface/api_trace.h" #define GRPC_SURFACE_TRACE_RETURNED_EVENT(cq, event) \ if (grpc_api_trace) { \ diff --git a/src/core/lib/transport/byte_stream.c b/src/core/lib/transport/byte_stream.c index cfba878dc4..79981aa154 100644 --- a/src/core/lib/transport/byte_stream.c +++ b/src/core/lib/transport/byte_stream.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/byte_stream.h" +#include "src/core/lib/transport/byte_stream.h" #include diff --git a/src/core/lib/transport/byte_stream.h b/src/core/lib/transport/byte_stream.h index ae01f91295..e7346dafc3 100644 --- a/src/core/lib/transport/byte_stream.h +++ b/src/core/lib/transport/byte_stream.h @@ -35,7 +35,7 @@ #define GRPC_CORE_LIB_TRANSPORT_BYTE_STREAM_H #include -#include "src/core/iomgr/exec_ctx.h" +#include "src/core/lib/iomgr/exec_ctx.h" /** Internal bit flag for grpc_begin_message's \a flags signaling the use of * compression for the message */ diff --git a/src/core/lib/transport/chttp2/alpn.c b/src/core/lib/transport/chttp2/alpn.c index 67fff21229..befe319180 100644 --- a/src/core/lib/transport/chttp2/alpn.c +++ b/src/core/lib/transport/chttp2/alpn.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/alpn.h" +#include "src/core/lib/transport/chttp2/alpn.h" #include #include diff --git a/src/core/lib/transport/chttp2/bin_encoder.c b/src/core/lib/transport/chttp2/bin_encoder.c index 3d31162499..79d0aa3d6f 100644 --- a/src/core/lib/transport/chttp2/bin_encoder.c +++ b/src/core/lib/transport/chttp2/bin_encoder.c @@ -31,12 +31,12 @@ * */ -#include "src/core/transport/chttp2/bin_encoder.h" +#include "src/core/lib/transport/chttp2/bin_encoder.h" #include #include -#include "src/core/transport/chttp2/huffsyms.h" +#include "src/core/lib/transport/chttp2/huffsyms.h" static const char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; diff --git a/src/core/lib/transport/chttp2/frame_data.c b/src/core/lib/transport/chttp2/frame_data.c index 6cc6d4eaf2..cf25c3ccc1 100644 --- a/src/core/lib/transport/chttp2/frame_data.c +++ b/src/core/lib/transport/chttp2/frame_data.c @@ -31,16 +31,16 @@ * */ -#include "src/core/transport/chttp2/frame_data.h" +#include "src/core/lib/transport/chttp2/frame_data.h" #include #include #include #include -#include "src/core/support/string.h" -#include "src/core/transport/chttp2/internal.h" -#include "src/core/transport/transport.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/transport/chttp2/internal.h" +#include "src/core/lib/transport/transport.h" grpc_chttp2_parse_error grpc_chttp2_data_parser_init( grpc_chttp2_data_parser *parser) { diff --git a/src/core/lib/transport/chttp2/frame_data.h b/src/core/lib/transport/chttp2/frame_data.h index 725863bbb7..da404a42c6 100644 --- a/src/core/lib/transport/chttp2/frame_data.h +++ b/src/core/lib/transport/chttp2/frame_data.h @@ -38,9 +38,9 @@ #include #include -#include "src/core/iomgr/exec_ctx.h" -#include "src/core/transport/byte_stream.h" -#include "src/core/transport/chttp2/frame.h" +#include "src/core/lib/iomgr/exec_ctx.h" +#include "src/core/lib/transport/byte_stream.h" +#include "src/core/lib/transport/chttp2/frame.h" typedef enum { GRPC_CHTTP2_DATA_FH_0, diff --git a/src/core/lib/transport/chttp2/frame_goaway.c b/src/core/lib/transport/chttp2/frame_goaway.c index 45a8e2e270..bb8c28df90 100644 --- a/src/core/lib/transport/chttp2/frame_goaway.c +++ b/src/core/lib/transport/chttp2/frame_goaway.c @@ -31,8 +31,8 @@ * */ -#include "src/core/transport/chttp2/frame_goaway.h" -#include "src/core/transport/chttp2/internal.h" +#include "src/core/lib/transport/chttp2/frame_goaway.h" +#include "src/core/lib/transport/chttp2/internal.h" #include diff --git a/src/core/lib/transport/chttp2/frame_goaway.h b/src/core/lib/transport/chttp2/frame_goaway.h index 1ed2b62ec6..f64c44f3d9 100644 --- a/src/core/lib/transport/chttp2/frame_goaway.h +++ b/src/core/lib/transport/chttp2/frame_goaway.h @@ -37,8 +37,8 @@ #include #include #include -#include "src/core/iomgr/exec_ctx.h" -#include "src/core/transport/chttp2/frame.h" +#include "src/core/lib/iomgr/exec_ctx.h" +#include "src/core/lib/transport/chttp2/frame.h" typedef enum { GRPC_CHTTP2_GOAWAY_LSI0, diff --git a/src/core/lib/transport/chttp2/frame_ping.c b/src/core/lib/transport/chttp2/frame_ping.c index d619edb2d6..14ca394264 100644 --- a/src/core/lib/transport/chttp2/frame_ping.c +++ b/src/core/lib/transport/chttp2/frame_ping.c @@ -31,8 +31,8 @@ * */ -#include "src/core/transport/chttp2/frame_ping.h" -#include "src/core/transport/chttp2/internal.h" +#include "src/core/lib/transport/chttp2/frame_ping.h" +#include "src/core/lib/transport/chttp2/internal.h" #include diff --git a/src/core/lib/transport/chttp2/frame_ping.h b/src/core/lib/transport/chttp2/frame_ping.h index 87bf1d3257..7640fc4773 100644 --- a/src/core/lib/transport/chttp2/frame_ping.h +++ b/src/core/lib/transport/chttp2/frame_ping.h @@ -35,8 +35,8 @@ #define GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_PING_H #include -#include "src/core/iomgr/exec_ctx.h" -#include "src/core/transport/chttp2/frame.h" +#include "src/core/lib/iomgr/exec_ctx.h" +#include "src/core/lib/transport/chttp2/frame.h" typedef struct { uint8_t byte; diff --git a/src/core/lib/transport/chttp2/frame_rst_stream.c b/src/core/lib/transport/chttp2/frame_rst_stream.c index 3b4aa623f2..060912afc4 100644 --- a/src/core/lib/transport/chttp2/frame_rst_stream.c +++ b/src/core/lib/transport/chttp2/frame_rst_stream.c @@ -31,12 +31,12 @@ * */ -#include "src/core/transport/chttp2/frame_rst_stream.h" -#include "src/core/transport/chttp2/internal.h" +#include "src/core/lib/transport/chttp2/frame_rst_stream.h" +#include "src/core/lib/transport/chttp2/internal.h" #include -#include "src/core/transport/chttp2/frame.h" +#include "src/core/lib/transport/chttp2/frame.h" gpr_slice grpc_chttp2_rst_stream_create(uint32_t id, uint32_t code) { gpr_slice slice = gpr_slice_malloc(13); diff --git a/src/core/lib/transport/chttp2/frame_rst_stream.h b/src/core/lib/transport/chttp2/frame_rst_stream.h index 2dd009d3c2..93155fde9d 100644 --- a/src/core/lib/transport/chttp2/frame_rst_stream.h +++ b/src/core/lib/transport/chttp2/frame_rst_stream.h @@ -35,8 +35,8 @@ #define GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_RST_STREAM_H #include -#include "src/core/iomgr/exec_ctx.h" -#include "src/core/transport/chttp2/frame.h" +#include "src/core/lib/iomgr/exec_ctx.h" +#include "src/core/lib/transport/chttp2/frame.h" typedef struct { uint8_t byte; diff --git a/src/core/lib/transport/chttp2/frame_settings.c b/src/core/lib/transport/chttp2/frame_settings.c index 9c5ad9f30e..48429c2a78 100644 --- a/src/core/lib/transport/chttp2/frame_settings.c +++ b/src/core/lib/transport/chttp2/frame_settings.c @@ -31,18 +31,18 @@ * */ -#include "src/core/transport/chttp2/frame_settings.h" -#include "src/core/transport/chttp2/internal.h" +#include "src/core/lib/transport/chttp2/frame_settings.h" +#include "src/core/lib/transport/chttp2/internal.h" #include #include #include -#include "src/core/debug/trace.h" -#include "src/core/transport/chttp2/frame.h" -#include "src/core/transport/chttp2/http2_errors.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/debug/trace.h" +#include "src/core/lib/transport/chttp2/frame.h" +#include "src/core/lib/transport/chttp2/http2_errors.h" +#include "src/core/lib/transport/chttp2_transport.h" #define MAX_MAX_HEADER_LIST_SIZE (1024 * 1024 * 1024) diff --git a/src/core/lib/transport/chttp2/frame_settings.h b/src/core/lib/transport/chttp2/frame_settings.h index fa1db96638..8b294de021 100644 --- a/src/core/lib/transport/chttp2/frame_settings.h +++ b/src/core/lib/transport/chttp2/frame_settings.h @@ -36,8 +36,8 @@ #include #include -#include "src/core/iomgr/exec_ctx.h" -#include "src/core/transport/chttp2/frame.h" +#include "src/core/lib/iomgr/exec_ctx.h" +#include "src/core/lib/transport/chttp2/frame.h" typedef enum { GRPC_CHTTP2_SPS_ID0, diff --git a/src/core/lib/transport/chttp2/frame_window_update.c b/src/core/lib/transport/chttp2/frame_window_update.c index 03b665c9cb..2ab5003316 100644 --- a/src/core/lib/transport/chttp2/frame_window_update.c +++ b/src/core/lib/transport/chttp2/frame_window_update.c @@ -31,8 +31,8 @@ * */ -#include "src/core/transport/chttp2/frame_window_update.h" -#include "src/core/transport/chttp2/internal.h" +#include "src/core/lib/transport/chttp2/frame_window_update.h" +#include "src/core/lib/transport/chttp2/internal.h" #include diff --git a/src/core/lib/transport/chttp2/frame_window_update.h b/src/core/lib/transport/chttp2/frame_window_update.h index 88e458bbfb..4b1aea294d 100644 --- a/src/core/lib/transport/chttp2/frame_window_update.h +++ b/src/core/lib/transport/chttp2/frame_window_update.h @@ -35,8 +35,8 @@ #define GRPC_CORE_LIB_TRANSPORT_CHTTP2_FRAME_WINDOW_UPDATE_H #include -#include "src/core/iomgr/exec_ctx.h" -#include "src/core/transport/chttp2/frame.h" +#include "src/core/lib/iomgr/exec_ctx.h" +#include "src/core/lib/transport/chttp2/frame.h" typedef struct { uint8_t byte; diff --git a/src/core/lib/transport/chttp2/hpack_encoder.c b/src/core/lib/transport/chttp2/hpack_encoder.c index f30f574d06..6b45929b04 100644 --- a/src/core/lib/transport/chttp2/hpack_encoder.c +++ b/src/core/lib/transport/chttp2/hpack_encoder.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/hpack_encoder.h" +#include "src/core/lib/transport/chttp2/hpack_encoder.h" #include #include @@ -45,11 +45,11 @@ #include #include -#include "src/core/transport/chttp2/bin_encoder.h" -#include "src/core/transport/chttp2/hpack_table.h" -#include "src/core/transport/chttp2/timeout_encoding.h" -#include "src/core/transport/chttp2/varint.h" -#include "src/core/transport/static_metadata.h" +#include "src/core/lib/transport/chttp2/bin_encoder.h" +#include "src/core/lib/transport/chttp2/hpack_table.h" +#include "src/core/lib/transport/chttp2/timeout_encoding.h" +#include "src/core/lib/transport/chttp2/varint.h" +#include "src/core/lib/transport/static_metadata.h" #define HASH_FRAGMENT_1(x) ((x)&255) #define HASH_FRAGMENT_2(x) ((x >> 8) & 255) diff --git a/src/core/lib/transport/chttp2/hpack_encoder.h b/src/core/lib/transport/chttp2/hpack_encoder.h index e842f5719e..de46a8f146 100644 --- a/src/core/lib/transport/chttp2/hpack_encoder.h +++ b/src/core/lib/transport/chttp2/hpack_encoder.h @@ -37,9 +37,9 @@ #include #include #include -#include "src/core/transport/chttp2/frame.h" -#include "src/core/transport/metadata.h" -#include "src/core/transport/metadata_batch.h" +#include "src/core/lib/transport/chttp2/frame.h" +#include "src/core/lib/transport/metadata.h" +#include "src/core/lib/transport/metadata_batch.h" #define GRPC_CHTTP2_HPACKC_NUM_FILTERS 256 #define GRPC_CHTTP2_HPACKC_NUM_VALUES 256 diff --git a/src/core/lib/transport/chttp2/hpack_parser.c b/src/core/lib/transport/chttp2/hpack_parser.c index b6e36923cb..d41ebab147 100644 --- a/src/core/lib/transport/chttp2/hpack_parser.c +++ b/src/core/lib/transport/chttp2/hpack_parser.c @@ -31,8 +31,8 @@ * */ -#include "src/core/transport/chttp2/hpack_parser.h" -#include "src/core/transport/chttp2/internal.h" +#include "src/core/lib/transport/chttp2/hpack_parser.h" +#include "src/core/lib/transport/chttp2/internal.h" #include #include @@ -48,9 +48,9 @@ #include #include -#include "src/core/profiling/timers.h" -#include "src/core/support/string.h" -#include "src/core/transport/chttp2/bin_encoder.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/transport/chttp2/bin_encoder.h" typedef enum { NOT_BINARY, diff --git a/src/core/lib/transport/chttp2/hpack_parser.h b/src/core/lib/transport/chttp2/hpack_parser.h index 2a47cdf93c..a534fd5cf4 100644 --- a/src/core/lib/transport/chttp2/hpack_parser.h +++ b/src/core/lib/transport/chttp2/hpack_parser.h @@ -37,10 +37,10 @@ #include #include -#include "src/core/iomgr/exec_ctx.h" -#include "src/core/transport/chttp2/frame.h" -#include "src/core/transport/chttp2/hpack_table.h" -#include "src/core/transport/metadata.h" +#include "src/core/lib/iomgr/exec_ctx.h" +#include "src/core/lib/transport/chttp2/frame.h" +#include "src/core/lib/transport/chttp2/hpack_table.h" +#include "src/core/lib/transport/metadata.h" typedef struct grpc_chttp2_hpack_parser grpc_chttp2_hpack_parser; diff --git a/src/core/lib/transport/chttp2/hpack_table.c b/src/core/lib/transport/chttp2/hpack_table.c index bf836e0139..f92bc26585 100644 --- a/src/core/lib/transport/chttp2/hpack_table.c +++ b/src/core/lib/transport/chttp2/hpack_table.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/hpack_table.h" +#include "src/core/lib/transport/chttp2/hpack_table.h" #include #include @@ -39,7 +39,7 @@ #include #include -#include "src/core/support/murmur_hash.h" +#include "src/core/lib/support/murmur_hash.h" static struct { const char *key; diff --git a/src/core/lib/transport/chttp2/hpack_table.h b/src/core/lib/transport/chttp2/hpack_table.h index eddb99ee1c..2cbc02dd9c 100644 --- a/src/core/lib/transport/chttp2/hpack_table.h +++ b/src/core/lib/transport/chttp2/hpack_table.h @@ -36,7 +36,7 @@ #include #include -#include "src/core/transport/metadata.h" +#include "src/core/lib/transport/metadata.h" /* HPACK header table */ diff --git a/src/core/lib/transport/chttp2/huffsyms.c b/src/core/lib/transport/chttp2/huffsyms.c index ebc85d3378..27497e6ae0 100644 --- a/src/core/lib/transport/chttp2/huffsyms.c +++ b/src/core/lib/transport/chttp2/huffsyms.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/huffsyms.h" +#include "src/core/lib/transport/chttp2/huffsyms.h" /* Constants pulled from the HPACK spec, and converted to C using the vim command: diff --git a/src/core/lib/transport/chttp2/incoming_metadata.c b/src/core/lib/transport/chttp2/incoming_metadata.c index 245d6ac15a..a1a8d37562 100644 --- a/src/core/lib/transport/chttp2/incoming_metadata.c +++ b/src/core/lib/transport/chttp2/incoming_metadata.c @@ -31,11 +31,11 @@ * */ -#include "src/core/transport/chttp2/incoming_metadata.h" +#include "src/core/lib/transport/chttp2/incoming_metadata.h" #include -#include "src/core/transport/chttp2/internal.h" +#include "src/core/lib/transport/chttp2/internal.h" #include #include diff --git a/src/core/lib/transport/chttp2/incoming_metadata.h b/src/core/lib/transport/chttp2/incoming_metadata.h index 87f360e1f2..edfa0adf9d 100644 --- a/src/core/lib/transport/chttp2/incoming_metadata.h +++ b/src/core/lib/transport/chttp2/incoming_metadata.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_INCOMING_METADATA_H #define GRPC_CORE_LIB_TRANSPORT_CHTTP2_INCOMING_METADATA_H -#include "src/core/transport/transport.h" +#include "src/core/lib/transport/transport.h" typedef struct { grpc_linked_mdelem *elems; diff --git a/src/core/lib/transport/chttp2/internal.h b/src/core/lib/transport/chttp2/internal.h index 2e7b334426..346e404204 100644 --- a/src/core/lib/transport/chttp2/internal.h +++ b/src/core/lib/transport/chttp2/internal.h @@ -37,20 +37,20 @@ #include #include -#include "src/core/iomgr/endpoint.h" -#include "src/core/transport/chttp2/frame.h" -#include "src/core/transport/chttp2/frame_data.h" -#include "src/core/transport/chttp2/frame_goaway.h" -#include "src/core/transport/chttp2/frame_ping.h" -#include "src/core/transport/chttp2/frame_rst_stream.h" -#include "src/core/transport/chttp2/frame_settings.h" -#include "src/core/transport/chttp2/frame_window_update.h" -#include "src/core/transport/chttp2/hpack_encoder.h" -#include "src/core/transport/chttp2/hpack_parser.h" -#include "src/core/transport/chttp2/incoming_metadata.h" -#include "src/core/transport/chttp2/stream_map.h" -#include "src/core/transport/connectivity_state.h" -#include "src/core/transport/transport_impl.h" +#include "src/core/lib/iomgr/endpoint.h" +#include "src/core/lib/transport/chttp2/frame.h" +#include "src/core/lib/transport/chttp2/frame_data.h" +#include "src/core/lib/transport/chttp2/frame_goaway.h" +#include "src/core/lib/transport/chttp2/frame_ping.h" +#include "src/core/lib/transport/chttp2/frame_rst_stream.h" +#include "src/core/lib/transport/chttp2/frame_settings.h" +#include "src/core/lib/transport/chttp2/frame_window_update.h" +#include "src/core/lib/transport/chttp2/hpack_encoder.h" +#include "src/core/lib/transport/chttp2/hpack_parser.h" +#include "src/core/lib/transport/chttp2/incoming_metadata.h" +#include "src/core/lib/transport/chttp2/stream_map.h" +#include "src/core/lib/transport/connectivity_state.h" +#include "src/core/lib/transport/transport_impl.h" typedef struct grpc_chttp2_transport grpc_chttp2_transport; typedef struct grpc_chttp2_stream grpc_chttp2_stream; diff --git a/src/core/lib/transport/chttp2/parsing.c b/src/core/lib/transport/chttp2/parsing.c index 0516f39fa9..9ee52f63f2 100644 --- a/src/core/lib/transport/chttp2/parsing.c +++ b/src/core/lib/transport/chttp2/parsing.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/internal.h" +#include "src/core/lib/transport/chttp2/internal.h" #include @@ -39,11 +39,11 @@ #include #include -#include "src/core/profiling/timers.h" -#include "src/core/transport/chttp2/http2_errors.h" -#include "src/core/transport/chttp2/status_conversion.h" -#include "src/core/transport/chttp2/timeout_encoding.h" -#include "src/core/transport/static_metadata.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/transport/chttp2/http2_errors.h" +#include "src/core/lib/transport/chttp2/status_conversion.h" +#include "src/core/lib/transport/chttp2/timeout_encoding.h" +#include "src/core/lib/transport/static_metadata.h" static int init_frame_parser(grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing); diff --git a/src/core/lib/transport/chttp2/status_conversion.c b/src/core/lib/transport/chttp2/status_conversion.c index cb566230fc..73dd63e720 100644 --- a/src/core/lib/transport/chttp2/status_conversion.c +++ b/src/core/lib/transport/chttp2/status_conversion.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/status_conversion.h" +#include "src/core/lib/transport/chttp2/status_conversion.h" int grpc_chttp2_grpc_status_to_http2_error(grpc_status_code status) { switch (status) { diff --git a/src/core/lib/transport/chttp2/status_conversion.h b/src/core/lib/transport/chttp2/status_conversion.h index 12720c05f9..241417d32e 100644 --- a/src/core/lib/transport/chttp2/status_conversion.h +++ b/src/core/lib/transport/chttp2/status_conversion.h @@ -35,7 +35,7 @@ #define GRPC_CORE_LIB_TRANSPORT_CHTTP2_STATUS_CONVERSION_H #include -#include "src/core/transport/chttp2/http2_errors.h" +#include "src/core/lib/transport/chttp2/http2_errors.h" /* Conversion of grpc status codes to http2 error codes (for RST_STREAM) */ grpc_chttp2_error_code grpc_chttp2_grpc_status_to_http2_error( diff --git a/src/core/lib/transport/chttp2/stream_lists.c b/src/core/lib/transport/chttp2/stream_lists.c index 60fe735cfc..b51a041dc7 100644 --- a/src/core/lib/transport/chttp2/stream_lists.c +++ b/src/core/lib/transport/chttp2/stream_lists.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/internal.h" +#include "src/core/lib/transport/chttp2/internal.h" #include diff --git a/src/core/lib/transport/chttp2/stream_map.c b/src/core/lib/transport/chttp2/stream_map.c index 6c70229e42..dbbbe783bf 100644 --- a/src/core/lib/transport/chttp2/stream_map.c +++ b/src/core/lib/transport/chttp2/stream_map.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/stream_map.h" +#include "src/core/lib/transport/chttp2/stream_map.h" #include diff --git a/src/core/lib/transport/chttp2/timeout_encoding.c b/src/core/lib/transport/chttp2/timeout_encoding.c index c4802e050e..0edacaafd3 100644 --- a/src/core/lib/transport/chttp2/timeout_encoding.c +++ b/src/core/lib/transport/chttp2/timeout_encoding.c @@ -31,13 +31,13 @@ * */ -#include "src/core/transport/chttp2/timeout_encoding.h" +#include "src/core/lib/transport/chttp2/timeout_encoding.h" #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" static int64_t round_up(int64_t x, int64_t divisor) { return (x / divisor + (x % divisor != 0)) * divisor; diff --git a/src/core/lib/transport/chttp2/timeout_encoding.h b/src/core/lib/transport/chttp2/timeout_encoding.h index 9bb3c36d72..731beb5a37 100644 --- a/src/core/lib/transport/chttp2/timeout_encoding.h +++ b/src/core/lib/transport/chttp2/timeout_encoding.h @@ -35,7 +35,7 @@ #define GRPC_CORE_LIB_TRANSPORT_CHTTP2_TIMEOUT_ENCODING_H #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #define GRPC_CHTTP2_TIMEOUT_ENCODE_MIN_BUFSIZE (GPR_LTOA_MIN_BUFSIZE + 1) diff --git a/src/core/lib/transport/chttp2/varint.c b/src/core/lib/transport/chttp2/varint.c index 1b0cf15eba..6dfef45362 100644 --- a/src/core/lib/transport/chttp2/varint.c +++ b/src/core/lib/transport/chttp2/varint.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/varint.h" +#include "src/core/lib/transport/chttp2/varint.h" uint32_t grpc_chttp2_hpack_varint_length(uint32_t tail_value) { if (tail_value < (1 << 7)) { diff --git a/src/core/lib/transport/chttp2/writing.c b/src/core/lib/transport/chttp2/writing.c index 107725cbc7..daea331d31 100644 --- a/src/core/lib/transport/chttp2/writing.c +++ b/src/core/lib/transport/chttp2/writing.c @@ -31,14 +31,14 @@ * */ -#include "src/core/transport/chttp2/internal.h" +#include "src/core/lib/transport/chttp2/internal.h" #include #include -#include "src/core/profiling/timers.h" -#include "src/core/transport/chttp2/http2_errors.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/transport/chttp2/http2_errors.h" static void finalize_outbuf(grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_writing *transport_writing); diff --git a/src/core/lib/transport/chttp2_transport.c b/src/core/lib/transport/chttp2_transport.c index b45bf31997..7fed3d8b47 100644 --- a/src/core/lib/transport/chttp2_transport.c +++ b/src/core/lib/transport/chttp2_transport.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/transport/chttp2_transport.h" #include #include @@ -43,14 +43,14 @@ #include #include -#include "src/core/profiling/timers.h" -#include "src/core/support/string.h" -#include "src/core/transport/chttp2/http2_errors.h" -#include "src/core/transport/chttp2/internal.h" -#include "src/core/transport/chttp2/status_conversion.h" -#include "src/core/transport/chttp2/timeout_encoding.h" -#include "src/core/transport/static_metadata.h" -#include "src/core/transport/transport_impl.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/transport/chttp2/http2_errors.h" +#include "src/core/lib/transport/chttp2/internal.h" +#include "src/core/lib/transport/chttp2/status_conversion.h" +#include "src/core/lib/transport/chttp2/timeout_encoding.h" +#include "src/core/lib/transport/static_metadata.h" +#include "src/core/lib/transport/transport_impl.h" #define DEFAULT_WINDOW 65535 #define DEFAULT_CONNECTION_WINDOW_TARGET (1024 * 1024) diff --git a/src/core/lib/transport/chttp2_transport.h b/src/core/lib/transport/chttp2_transport.h index b188219982..5008cab7f8 100644 --- a/src/core/lib/transport/chttp2_transport.h +++ b/src/core/lib/transport/chttp2_transport.h @@ -34,8 +34,8 @@ #ifndef GRPC_CORE_LIB_TRANSPORT_CHTTP2_TRANSPORT_H #define GRPC_CORE_LIB_TRANSPORT_CHTTP2_TRANSPORT_H -#include "src/core/iomgr/endpoint.h" -#include "src/core/transport/transport.h" +#include "src/core/lib/iomgr/endpoint.h" +#include "src/core/lib/transport/transport.h" extern int grpc_http_trace; extern int grpc_flowctl_trace; diff --git a/src/core/lib/transport/connectivity_state.c b/src/core/lib/transport/connectivity_state.c index 87765b9799..123eab8b36 100644 --- a/src/core/lib/transport/connectivity_state.c +++ b/src/core/lib/transport/connectivity_state.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/connectivity_state.h" +#include "src/core/lib/transport/connectivity_state.h" #include diff --git a/src/core/lib/transport/connectivity_state.h b/src/core/lib/transport/connectivity_state.h index dc6623c46c..6f92132438 100644 --- a/src/core/lib/transport/connectivity_state.h +++ b/src/core/lib/transport/connectivity_state.h @@ -35,7 +35,7 @@ #define GRPC_CORE_LIB_TRANSPORT_CONNECTIVITY_STATE_H #include -#include "src/core/iomgr/exec_ctx.h" +#include "src/core/lib/iomgr/exec_ctx.h" typedef struct grpc_connectivity_state_watcher { /** we keep watchers in a linked list */ diff --git a/src/core/lib/transport/metadata.c b/src/core/lib/transport/metadata.c index 7ed28feca8..7605f09991 100644 --- a/src/core/lib/transport/metadata.c +++ b/src/core/lib/transport/metadata.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/metadata.h" +#include "src/core/lib/transport/metadata.h" #include #include @@ -44,12 +44,12 @@ #include #include -#include "src/core/iomgr/iomgr_internal.h" -#include "src/core/profiling/timers.h" -#include "src/core/support/murmur_hash.h" -#include "src/core/support/string.h" -#include "src/core/transport/chttp2/bin_encoder.h" -#include "src/core/transport/static_metadata.h" +#include "src/core/lib/iomgr/iomgr_internal.h" +#include "src/core/lib/profiling/timers.h" +#include "src/core/lib/support/murmur_hash.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/transport/chttp2/bin_encoder.h" +#include "src/core/lib/transport/static_metadata.h" /* There are two kinds of mdelem and mdstr instances. * Static instances are declared in static_metadata.{h,c} and diff --git a/src/core/lib/transport/metadata_batch.c b/src/core/lib/transport/metadata_batch.c index 2e27b461c9..bb79b8fa96 100644 --- a/src/core/lib/transport/metadata_batch.c +++ b/src/core/lib/transport/metadata_batch.c @@ -31,14 +31,14 @@ * */ -#include "src/core/transport/metadata_batch.h" +#include "src/core/lib/transport/metadata_batch.h" #include #include #include -#include "src/core/profiling/timers.h" +#include "src/core/lib/profiling/timers.h" static void assert_valid_list(grpc_mdelem_list *list) { #ifndef NDEBUG diff --git a/src/core/lib/transport/metadata_batch.h b/src/core/lib/transport/metadata_batch.h index 4c9395e6c0..f1d4726989 100644 --- a/src/core/lib/transport/metadata_batch.h +++ b/src/core/lib/transport/metadata_batch.h @@ -38,7 +38,7 @@ #include #include #include -#include "src/core/transport/metadata.h" +#include "src/core/lib/transport/metadata.h" typedef struct grpc_linked_mdelem { grpc_mdelem *md; diff --git a/src/core/lib/transport/static_metadata.c b/src/core/lib/transport/static_metadata.c index 30bbb89880..eda277b3dc 100644 --- a/src/core/lib/transport/static_metadata.c +++ b/src/core/lib/transport/static_metadata.c @@ -43,7 +43,7 @@ * explanation of what's going on. */ -#include "src/core/transport/static_metadata.h" +#include "src/core/lib/transport/static_metadata.h" grpc_mdstr grpc_static_mdstr_table[GRPC_STATIC_MDSTR_COUNT]; diff --git a/src/core/lib/transport/static_metadata.h b/src/core/lib/transport/static_metadata.h index bfcb010387..aff136a6d2 100644 --- a/src/core/lib/transport/static_metadata.h +++ b/src/core/lib/transport/static_metadata.h @@ -46,7 +46,7 @@ #ifndef GRPC_CORE_LIB_TRANSPORT_STATIC_METADATA_H #define GRPC_CORE_LIB_TRANSPORT_STATIC_METADATA_H -#include "src/core/transport/metadata.h" +#include "src/core/lib/transport/metadata.h" #define GRPC_STATIC_MDSTR_COUNT 89 extern grpc_mdstr grpc_static_mdstr_table[GRPC_STATIC_MDSTR_COUNT]; diff --git a/src/core/lib/transport/transport.c b/src/core/lib/transport/transport.c index 3b555fa933..18256aae5e 100644 --- a/src/core/lib/transport/transport.c +++ b/src/core/lib/transport/transport.c @@ -31,11 +31,11 @@ * */ -#include "src/core/transport/transport.h" +#include "src/core/lib/transport/transport.h" #include #include #include -#include "src/core/transport/transport_impl.h" +#include "src/core/lib/transport/transport_impl.h" #ifdef GRPC_STREAM_REFCOUNT_DEBUG void grpc_stream_ref(grpc_stream_refcount *refcount, const char *reason) { diff --git a/src/core/lib/transport/transport.h b/src/core/lib/transport/transport.h index 4174f049d5..e98cfe9515 100644 --- a/src/core/lib/transport/transport.h +++ b/src/core/lib/transport/transport.h @@ -36,11 +36,11 @@ #include -#include "src/core/channel/context.h" -#include "src/core/iomgr/pollset.h" -#include "src/core/iomgr/pollset_set.h" -#include "src/core/transport/byte_stream.h" -#include "src/core/transport/metadata_batch.h" +#include "src/core/lib/channel/context.h" +#include "src/core/lib/iomgr/pollset.h" +#include "src/core/lib/iomgr/pollset_set.h" +#include "src/core/lib/transport/byte_stream.h" +#include "src/core/lib/transport/metadata_batch.h" /* forward declarations */ typedef struct grpc_transport grpc_transport; diff --git a/src/core/lib/transport/transport_impl.h b/src/core/lib/transport/transport_impl.h index 60fd27a8dc..92fa5d519d 100644 --- a/src/core/lib/transport/transport_impl.h +++ b/src/core/lib/transport/transport_impl.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_TRANSPORT_TRANSPORT_IMPL_H #define GRPC_CORE_LIB_TRANSPORT_TRANSPORT_IMPL_H -#include "src/core/transport/transport.h" +#include "src/core/lib/transport/transport.h" typedef struct grpc_transport_vtable { /* Memory required for a single stream element - this is allocated by upper diff --git a/src/core/lib/transport/transport_op_string.c b/src/core/lib/transport/transport_op_string.c index 8453412480..1fa8fa5d4f 100644 --- a/src/core/lib/transport/transport_op_string.c +++ b/src/core/lib/transport/transport_op_string.c @@ -31,7 +31,7 @@ * */ -#include "src/core/channel/channel_stack.h" +#include "src/core/lib/channel/channel_stack.h" #include #include @@ -40,7 +40,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" /* These routines are here to facilitate debugging - they produce string representations of various transport data structures */ diff --git a/src/core/lib/tsi/fake_transport_security.c b/src/core/lib/tsi/fake_transport_security.c index c0106f7a33..4b812f4803 100644 --- a/src/core/lib/tsi/fake_transport_security.c +++ b/src/core/lib/tsi/fake_transport_security.c @@ -31,7 +31,7 @@ * */ -#include "src/core/tsi/fake_transport_security.h" +#include "src/core/lib/tsi/fake_transport_security.h" #include #include @@ -39,7 +39,7 @@ #include #include #include -#include "src/core/tsi/transport_security.h" +#include "src/core/lib/tsi/transport_security.h" /* --- Constants. ---*/ #define TSI_FAKE_FRAME_HEADER_SIZE 4 diff --git a/src/core/lib/tsi/fake_transport_security.h b/src/core/lib/tsi/fake_transport_security.h index 718c1a50db..b887dfcb09 100644 --- a/src/core/lib/tsi/fake_transport_security.h +++ b/src/core/lib/tsi/fake_transport_security.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_TSI_FAKE_TRANSPORT_SECURITY_H #define GRPC_CORE_LIB_TSI_FAKE_TRANSPORT_SECURITY_H -#include "src/core/tsi/transport_security_interface.h" +#include "src/core/lib/tsi/transport_security_interface.h" #ifdef __cplusplus extern "C" { diff --git a/src/core/lib/tsi/ssl_transport_security.c b/src/core/lib/tsi/ssl_transport_security.c index 8df582609b..d03201eec6 100644 --- a/src/core/lib/tsi/ssl_transport_security.c +++ b/src/core/lib/tsi/ssl_transport_security.c @@ -31,7 +31,7 @@ * */ -#include "src/core/tsi/ssl_transport_security.h" +#include "src/core/lib/tsi/ssl_transport_security.h" #include @@ -57,8 +57,8 @@ #include #include -#include "src/core/tsi/ssl_types.h" -#include "src/core/tsi/transport_security.h" +#include "src/core/lib/tsi/ssl_types.h" +#include "src/core/lib/tsi/transport_security.h" /* --- Constants. ---*/ diff --git a/src/core/lib/tsi/ssl_transport_security.h b/src/core/lib/tsi/ssl_transport_security.h index 441b010e4e..c9b9e8f54b 100644 --- a/src/core/lib/tsi/ssl_transport_security.h +++ b/src/core/lib/tsi/ssl_transport_security.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_TSI_SSL_TRANSPORT_SECURITY_H #define GRPC_CORE_LIB_TSI_SSL_TRANSPORT_SECURITY_H -#include "src/core/tsi/transport_security_interface.h" +#include "src/core/lib/tsi/transport_security_interface.h" #ifdef __cplusplus extern "C" { diff --git a/src/core/lib/tsi/transport_security.c b/src/core/lib/tsi/transport_security.c index 64aac2c05a..a2c0d46196 100644 --- a/src/core/lib/tsi/transport_security.c +++ b/src/core/lib/tsi/transport_security.c @@ -31,7 +31,7 @@ * */ -#include "src/core/tsi/transport_security.h" +#include "src/core/lib/tsi/transport_security.h" #include #include diff --git a/src/core/lib/tsi/transport_security.h b/src/core/lib/tsi/transport_security.h index 292af7ffb9..349dd0ae9c 100644 --- a/src/core/lib/tsi/transport_security.h +++ b/src/core/lib/tsi/transport_security.h @@ -34,7 +34,7 @@ #ifndef GRPC_CORE_LIB_TSI_TRANSPORT_SECURITY_H #define GRPC_CORE_LIB_TSI_TRANSPORT_SECURITY_H -#include "src/core/tsi/transport_security_interface.h" +#include "src/core/lib/tsi/transport_security_interface.h" #ifdef __cplusplus extern "C" { diff --git a/src/cpp/client/channel.cc b/src/cpp/client/channel.cc index ae20392d11..f174676172 100644 --- a/src/cpp/client/channel.cc +++ b/src/cpp/client/channel.cc @@ -49,7 +49,7 @@ #include #include #include -#include "src/core/profiling/timers.h" +#include "src/core/lib/profiling/timers.h" namespace grpc { diff --git a/src/cpp/client/client_context.cc b/src/cpp/client/client_context.cc index db636a5456..de8b2db6e3 100644 --- a/src/cpp/client/client_context.cc +++ b/src/cpp/client/client_context.cc @@ -41,7 +41,7 @@ #include #include -#include "src/core/channel/compress_filter.h" +#include "src/core/lib/channel/compress_filter.h" #include "src/cpp/common/create_auth_context.h" namespace grpc { diff --git a/src/cpp/common/channel_arguments.cc b/src/cpp/common/channel_arguments.cc index d7faa5e173..3bdb4398ab 100644 --- a/src/cpp/common/channel_arguments.cc +++ b/src/cpp/common/channel_arguments.cc @@ -36,7 +36,7 @@ #include #include -#include "src/core/channel/channel_args.h" +#include "src/core/lib/channel/channel_args.h" namespace grpc { diff --git a/src/cpp/common/core_codegen.cc b/src/cpp/common/core_codegen.cc index 45e9e278a0..33a8f755e6 100644 --- a/src/cpp/common/core_codegen.cc +++ b/src/cpp/common/core_codegen.cc @@ -46,7 +46,7 @@ #include #include -#include "src/core/profiling/timers.h" +#include "src/core/lib/profiling/timers.h" namespace { diff --git a/src/cpp/common/secure_channel_arguments.cc b/src/cpp/common/secure_channel_arguments.cc index e17d3b58b0..81ec251b92 100644 --- a/src/cpp/common/secure_channel_arguments.cc +++ b/src/cpp/common/secure_channel_arguments.cc @@ -34,7 +34,7 @@ #include #include -#include "src/core/channel/channel_args.h" +#include "src/core/lib/channel/channel_args.h" namespace grpc { diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc index 6d31a608c8..7e5f557ffa 100644 --- a/src/cpp/server/server.cc +++ b/src/cpp/server/server.cc @@ -49,7 +49,7 @@ #include #include -#include "src/core/profiling/timers.h" +#include "src/core/lib/profiling/timers.h" #include "src/cpp/server/thread_pool_interface.h" namespace grpc { diff --git a/src/cpp/server/server_context.cc b/src/cpp/server/server_context.cc index 5d12ce2ecf..0422650953 100644 --- a/src/cpp/server/server_context.cc +++ b/src/cpp/server/server_context.cc @@ -42,8 +42,8 @@ #include #include -#include "src/core/channel/compress_filter.h" -#include "src/core/surface/call.h" +#include "src/core/lib/channel/compress_filter.h" +#include "src/core/lib/surface/call.h" #include "src/cpp/common/create_auth_context.h" namespace grpc { diff --git a/src/csharp/ext/grpc_csharp_ext.c b/src/csharp/ext/grpc_csharp_ext.c index 1df74a0993..642dc9ef42 100644 --- a/src/csharp/ext/grpc_csharp_ext.c +++ b/src/csharp/ext/grpc_csharp_ext.c @@ -31,7 +31,7 @@ * */ -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include #include diff --git a/test/core/bad_client/bad_client.c b/test/core/bad_client/bad_client.c index c7130f9580..2e9623e5ec 100644 --- a/test/core/bad_client/bad_client.c +++ b/test/core/bad_client/bad_client.c @@ -33,13 +33,13 @@ #include "test/core/bad_client/bad_client.h" -#include "src/core/channel/channel_stack.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/iomgr/endpoint_pair.h" -#include "src/core/support/string.h" -#include "src/core/surface/completion_queue.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/iomgr/endpoint_pair.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/completion_queue.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" #include #include diff --git a/test/core/bad_client/tests/badreq.c b/test/core/bad_client/tests/badreq.c index 95d46d5731..fd3d13f908 100644 --- a/test/core/bad_client/tests/badreq.c +++ b/test/core/bad_client/tests/badreq.c @@ -35,7 +35,7 @@ #include -#include "src/core/surface/server.h" +#include "src/core/lib/surface/server.h" #include "test/core/end2end/cq_verifier.h" #define PFX_STR \ diff --git a/test/core/bad_client/tests/connection_prefix.c b/test/core/bad_client/tests/connection_prefix.c index 000ecca6c6..87826afa2c 100644 --- a/test/core/bad_client/tests/connection_prefix.c +++ b/test/core/bad_client/tests/connection_prefix.c @@ -31,7 +31,7 @@ * */ -#include "src/core/surface/server.h" +#include "src/core/lib/surface/server.h" #include "test/core/bad_client/bad_client.h" static void verifier(grpc_server *server, grpc_completion_queue *cq, diff --git a/test/core/bad_client/tests/headers.c b/test/core/bad_client/tests/headers.c index 4ecdb64139..f66f14d8aa 100644 --- a/test/core/bad_client/tests/headers.c +++ b/test/core/bad_client/tests/headers.c @@ -31,7 +31,7 @@ * */ -#include "src/core/surface/server.h" +#include "src/core/lib/surface/server.h" #include "test/core/bad_client/bad_client.h" #define PFX_STR \ diff --git a/test/core/bad_client/tests/initial_settings_frame.c b/test/core/bad_client/tests/initial_settings_frame.c index 2104892766..b303f033f1 100644 --- a/test/core/bad_client/tests/initial_settings_frame.c +++ b/test/core/bad_client/tests/initial_settings_frame.c @@ -31,7 +31,7 @@ * */ -#include "src/core/surface/server.h" +#include "src/core/lib/surface/server.h" #include "test/core/bad_client/bad_client.h" #define PFX_STR "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n" diff --git a/test/core/bad_client/tests/server_registered_method.c b/test/core/bad_client/tests/server_registered_method.c index d280804687..c35457c3f8 100644 --- a/test/core/bad_client/tests/server_registered_method.c +++ b/test/core/bad_client/tests/server_registered_method.c @@ -35,7 +35,7 @@ #include -#include "src/core/surface/server.h" +#include "src/core/lib/surface/server.h" #include "test/core/end2end/cq_verifier.h" #define PFX_STR \ diff --git a/test/core/bad_client/tests/simple_request.c b/test/core/bad_client/tests/simple_request.c index e535be1527..6cb44ee273 100644 --- a/test/core/bad_client/tests/simple_request.c +++ b/test/core/bad_client/tests/simple_request.c @@ -35,7 +35,7 @@ #include -#include "src/core/surface/server.h" +#include "src/core/lib/surface/server.h" #include "test/core/end2end/cq_verifier.h" #define PFX_STR \ diff --git a/test/core/bad_client/tests/unknown_frame.c b/test/core/bad_client/tests/unknown_frame.c index 729a6d9a75..44d1e35299 100644 --- a/test/core/bad_client/tests/unknown_frame.c +++ b/test/core/bad_client/tests/unknown_frame.c @@ -31,7 +31,7 @@ * */ -#include "src/core/surface/server.h" +#include "src/core/lib/surface/server.h" #include "test/core/bad_client/bad_client.h" #define PFX_STR \ diff --git a/test/core/bad_client/tests/window_overflow.c b/test/core/bad_client/tests/window_overflow.c index a9117de36a..b6d0101c80 100644 --- a/test/core/bad_client/tests/window_overflow.c +++ b/test/core/bad_client/tests/window_overflow.c @@ -37,7 +37,7 @@ #include -#include "src/core/surface/server.h" +#include "src/core/lib/surface/server.h" #define PFX_STR \ "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n" \ diff --git a/test/core/bad_ssl/bad_ssl_test.c b/test/core/bad_ssl/bad_ssl_test.c index e2babfa114..013b8eaf13 100644 --- a/test/core/bad_ssl/bad_ssl_test.c +++ b/test/core/bad_ssl/bad_ssl_test.c @@ -41,8 +41,8 @@ #include #include #include -#include "src/core/support/env.h" -#include "src/core/support/string.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/support/string.h" #include "test/core/end2end/cq_verifier.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/bad_ssl/servers/alpn.c b/test/core/bad_ssl/servers/alpn.c index c8cc83b134..98dcd1c0ca 100644 --- a/test/core/bad_ssl/servers/alpn.c +++ b/test/core/bad_ssl/servers/alpn.c @@ -38,7 +38,7 @@ #include #include -#include "src/core/transport/chttp2/alpn.h" +#include "src/core/lib/transport/chttp2/alpn.h" #include "test/core/bad_ssl/server_common.h" #include "test/core/end2end/data/ssl_test_data.h" diff --git a/test/core/bad_ssl/servers/cert.c b/test/core/bad_ssl/servers/cert.c index 4edef50b67..9661347470 100644 --- a/test/core/bad_ssl/servers/cert.c +++ b/test/core/bad_ssl/servers/cert.c @@ -38,7 +38,7 @@ #include #include -#include "src/core/support/load_file.h" +#include "src/core/lib/support/load_file.h" #include "test/core/bad_ssl/server_common.h" #include "test/core/end2end/data/ssl_test_data.h" diff --git a/test/core/census/mlog_test.c b/test/core/census/mlog_test.c index 000ac7335a..a1fadc2290 100644 --- a/test/core/census/mlog_test.c +++ b/test/core/census/mlog_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/census/mlog.h" +#include "src/core/lib/census/mlog.h" #include #include #include diff --git a/test/core/channel/channel_args_test.c b/test/core/channel/channel_args_test.c index 0b74dee41e..c7fc25960c 100644 --- a/test/core/channel/channel_args_test.c +++ b/test/core/channel/channel_args_test.c @@ -36,7 +36,7 @@ #include #include -#include "src/core/channel/channel_args.h" +#include "src/core/lib/channel/channel_args.h" #include "test/core/util/test_config.h" diff --git a/test/core/channel/channel_stack_test.c b/test/core/channel/channel_stack_test.c index c4c288d736..49e9c7e969 100644 --- a/test/core/channel/channel_stack_test.c +++ b/test/core/channel/channel_stack_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/channel/channel_stack.h" +#include "src/core/lib/channel/channel_stack.h" #include diff --git a/test/core/client_config/lb_policies_test.c b/test/core/client_config/lb_policies_test.c index 91fa63ea97..bae3e7d18c 100644 --- a/test/core/client_config/lb_policies_test.c +++ b/test/core/client_config/lb_policies_test.c @@ -41,13 +41,13 @@ #include #include -#include "src/core/channel/channel_stack.h" -#include "src/core/channel/client_channel.h" -#include "src/core/client_config/lb_policies/round_robin.h" -#include "src/core/client_config/lb_policy_registry.h" -#include "src/core/support/string.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/server.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/client_config/lb_policies/round_robin.h" +#include "src/core/lib/client_config/lb_policy_registry.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/server.h" #include "test/core/end2end/cq_verifier.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/client_config/resolvers/dns_resolver_connectivity_test.c b/test/core/client_config/resolvers/dns_resolver_connectivity_test.c index 75d1eb674f..dc6a614d55 100644 --- a/test/core/client_config/resolvers/dns_resolver_connectivity_test.c +++ b/test/core/client_config/resolvers/dns_resolver_connectivity_test.c @@ -31,15 +31,15 @@ * */ -#include "src/core/client_config/resolvers/dns_resolver.h" +#include "src/core/lib/client_config/resolvers/dns_resolver.h" #include #include #include -#include "src/core/iomgr/resolve_address.h" -#include "src/core/iomgr/timer.h" +#include "src/core/lib/iomgr/resolve_address.h" +#include "src/core/lib/iomgr/timer.h" #include "test/core/util/test_config.h" static void subchannel_factory_ref(grpc_subchannel_factory *scv) {} diff --git a/test/core/client_config/resolvers/dns_resolver_test.c b/test/core/client_config/resolvers/dns_resolver_test.c index 38e76d5342..043b882184 100644 --- a/test/core/client_config/resolvers/dns_resolver_test.c +++ b/test/core/client_config/resolvers/dns_resolver_test.c @@ -31,13 +31,13 @@ * */ -#include "src/core/client_config/resolvers/dns_resolver.h" +#include "src/core/lib/client_config/resolvers/dns_resolver.h" #include #include -#include "src/core/client_config/resolver.h" +#include "src/core/lib/client_config/resolver.h" #include "test/core/util/test_config.h" static void subchannel_factory_ref(grpc_subchannel_factory *scv) {} diff --git a/test/core/client_config/resolvers/sockaddr_resolver_test.c b/test/core/client_config/resolvers/sockaddr_resolver_test.c index 8856c85449..e23616ca23 100644 --- a/test/core/client_config/resolvers/sockaddr_resolver_test.c +++ b/test/core/client_config/resolvers/sockaddr_resolver_test.c @@ -31,13 +31,13 @@ * */ -#include "src/core/client_config/resolvers/sockaddr_resolver.h" +#include "src/core/lib/client_config/resolvers/sockaddr_resolver.h" #include #include -#include "src/core/client_config/resolver.h" +#include "src/core/lib/client_config/resolver.h" #include "test/core/util/test_config.h" static void subchannel_factory_ref(grpc_subchannel_factory *scv) {} diff --git a/test/core/client_config/set_initial_connect_string_test.c b/test/core/client_config/set_initial_connect_string_test.c index 3cf267fb3b..7fd92a079e 100644 --- a/test/core/client_config/set_initial_connect_string_test.c +++ b/test/core/client_config/set_initial_connect_string_test.c @@ -38,10 +38,10 @@ #include #include -#include "src/core/client_config/initial_connect_string.h" -#include "src/core/iomgr/sockaddr.h" -#include "src/core/security/credentials.h" -#include "src/core/support/string.h" +#include "src/core/lib/client_config/initial_connect_string.h" +#include "src/core/lib/iomgr/sockaddr.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/support/string.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" #include "test/core/util/test_tcp_server.h" diff --git a/test/core/client_config/uri_parser_test.c b/test/core/client_config/uri_parser_test.c index df12d6b4cb..e5d0c378ba 100644 --- a/test/core/client_config/uri_parser_test.c +++ b/test/core/client_config/uri_parser_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/client_config/uri_parser.h" +#include "src/core/lib/client_config/uri_parser.h" #include diff --git a/test/core/compression/algorithm_test.c b/test/core/compression/algorithm_test.c index 7de7e11a94..bdee748ae6 100644 --- a/test/core/compression/algorithm_test.c +++ b/test/core/compression/algorithm_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/compression/algorithm_metadata.h" +#include "src/core/lib/compression/algorithm_metadata.h" #include #include @@ -40,7 +40,7 @@ #include #include -#include "src/core/transport/static_metadata.h" +#include "src/core/lib/transport/static_metadata.h" #include "test/core/util/test_config.h" static void test_algorithm_mesh(void) { diff --git a/test/core/compression/message_compress_test.c b/test/core/compression/message_compress_test.c index 6d3d16128a..1a93903346 100644 --- a/test/core/compression/message_compress_test.c +++ b/test/core/compression/message_compress_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/compression/message_compress.h" +#include "src/core/lib/compression/message_compress.h" #include #include @@ -40,7 +40,7 @@ #include #include -#include "src/core/support/murmur_hash.h" +#include "src/core/lib/support/murmur_hash.h" #include "test/core/util/slice_splitter.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/cq_verifier.c b/test/core/end2end/cq_verifier.c index 3687f7caf4..baf8e8ed18 100644 --- a/test/core/end2end/cq_verifier.c +++ b/test/core/end2end/cq_verifier.c @@ -44,8 +44,8 @@ #include #include #include -#include "src/core/support/string.h" -#include "src/core/surface/event_string.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/event_string.h" #define ROOT_EXPECTATION 1000 diff --git a/test/core/end2end/dualstack_socket_test.c b/test/core/end2end/dualstack_socket_test.c index 77589a7eee..7501df98dc 100644 --- a/test/core/end2end/dualstack_socket_test.c +++ b/test/core/end2end/dualstack_socket_test.c @@ -39,9 +39,9 @@ #include #include -#include "src/core/iomgr/resolve_address.h" -#include "src/core/iomgr/socket_utils_posix.h" -#include "src/core/support/string.h" +#include "src/core/lib/iomgr/resolve_address.h" +#include "src/core/lib/iomgr/socket_utils_posix.h" +#include "src/core/lib/support/string.h" #include "test/core/end2end/cq_verifier.h" #include "test/core/util/port.h" diff --git a/test/core/end2end/fixtures/h2_census.c b/test/core/end2end/fixtures/h2_census.c index 4d89a8f8c3..8d504e4598 100644 --- a/test/core/end2end/fixtures/h2_census.c +++ b/test/core/end2end/fixtures/h2_census.c @@ -41,13 +41,13 @@ #include #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/channel/client_channel.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_compress.c b/test/core/end2end/fixtures/h2_compress.c index 19a2495eaf..a45c27af7a 100644 --- a/test/core/end2end/fixtures/h2_compress.c +++ b/test/core/end2end/fixtures/h2_compress.c @@ -41,13 +41,13 @@ #include #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/channel/client_channel.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_fakesec.c b/test/core/end2end/fixtures/h2_fakesec.c index 8be8e35b1a..7386691bdc 100644 --- a/test/core/end2end/fixtures/h2_fakesec.c +++ b/test/core/end2end/fixtures/h2_fakesec.c @@ -39,8 +39,8 @@ #include #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/security/credentials.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/security/credentials.h" #include "test/core/end2end/data/ssl_test_data.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_full+pipe.c b/test/core/end2end/fixtures/h2_full+pipe.c index f2d72f0445..def5efaa42 100644 --- a/test/core/end2end/fixtures/h2_full+pipe.c +++ b/test/core/end2end/fixtures/h2_full+pipe.c @@ -41,13 +41,13 @@ #include #include #include -#include "src/core/channel/client_channel.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/iomgr/wakeup_fd_posix.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/iomgr/wakeup_fd_posix.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_full+poll+pipe.c b/test/core/end2end/fixtures/h2_full+poll+pipe.c index 682598fbe2..0584b81448 100644 --- a/test/core/end2end/fixtures/h2_full+poll+pipe.c +++ b/test/core/end2end/fixtures/h2_full+poll+pipe.c @@ -42,14 +42,14 @@ #include #include -#include "src/core/channel/client_channel.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/iomgr/pollset_posix.h" -#include "src/core/iomgr/wakeup_fd_posix.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/iomgr/pollset_posix.h" +#include "src/core/lib/iomgr/wakeup_fd_posix.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_full+poll.c b/test/core/end2end/fixtures/h2_full+poll.c index 5a0b2ef495..8576e3ee90 100644 --- a/test/core/end2end/fixtures/h2_full+poll.c +++ b/test/core/end2end/fixtures/h2_full+poll.c @@ -42,13 +42,13 @@ #include #include -#include "src/core/channel/client_channel.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/iomgr/pollset_posix.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/iomgr/pollset_posix.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_full+trace.c b/test/core/end2end/fixtures/h2_full+trace.c index c84bd72530..0d531565f2 100644 --- a/test/core/end2end/fixtures/h2_full+trace.c +++ b/test/core/end2end/fixtures/h2_full+trace.c @@ -41,13 +41,13 @@ #include #include #include -#include "src/core/channel/client_channel.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/support/env.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_full.c b/test/core/end2end/fixtures/h2_full.c index c56d2fc073..4eae620935 100644 --- a/test/core/end2end/fixtures/h2_full.c +++ b/test/core/end2end/fixtures/h2_full.c @@ -41,12 +41,12 @@ #include #include #include -#include "src/core/channel/client_channel.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_oauth2.c b/test/core/end2end/fixtures/h2_oauth2.c index 279061b99e..ee188cc174 100644 --- a/test/core/end2end/fixtures/h2_oauth2.c +++ b/test/core/end2end/fixtures/h2_oauth2.c @@ -39,9 +39,9 @@ #include #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/iomgr/iomgr.h" -#include "src/core/security/credentials.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/security/credentials.h" #include "test/core/end2end/data/ssl_test_data.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_proxy.c b/test/core/end2end/fixtures/h2_proxy.c index 1e9aa624e3..39ecd89293 100644 --- a/test/core/end2end/fixtures/h2_proxy.c +++ b/test/core/end2end/fixtures/h2_proxy.c @@ -41,12 +41,12 @@ #include #include #include -#include "src/core/channel/client_channel.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" #include "test/core/end2end/fixtures/proxy.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_sockpair+trace.c b/test/core/end2end/fixtures/h2_sockpair+trace.c index 33068721fa..374390fb29 100644 --- a/test/core/end2end/fixtures/h2_sockpair+trace.c +++ b/test/core/end2end/fixtures/h2_sockpair+trace.c @@ -40,17 +40,17 @@ #include #include #include -#include "src/core/channel/client_channel.h" -#include "src/core/channel/compress_filter.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/http_client_filter.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/iomgr/endpoint_pair.h" -#include "src/core/iomgr/iomgr.h" -#include "src/core/support/env.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/compress_filter.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/http_client_filter.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/iomgr/endpoint_pair.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_sockpair.c b/test/core/end2end/fixtures/h2_sockpair.c index d64c85aea8..c11a528116 100644 --- a/test/core/end2end/fixtures/h2_sockpair.c +++ b/test/core/end2end/fixtures/h2_sockpair.c @@ -40,16 +40,16 @@ #include #include #include -#include "src/core/channel/client_channel.h" -#include "src/core/channel/compress_filter.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/http_client_filter.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/iomgr/endpoint_pair.h" -#include "src/core/iomgr/iomgr.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/compress_filter.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/http_client_filter.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/iomgr/endpoint_pair.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_sockpair_1byte.c b/test/core/end2end/fixtures/h2_sockpair_1byte.c index 67180a5edb..6a504c6a9c 100644 --- a/test/core/end2end/fixtures/h2_sockpair_1byte.c +++ b/test/core/end2end/fixtures/h2_sockpair_1byte.c @@ -40,16 +40,16 @@ #include #include #include -#include "src/core/channel/client_channel.h" -#include "src/core/channel/compress_filter.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/http_client_filter.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/iomgr/endpoint_pair.h" -#include "src/core/iomgr/iomgr.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/compress_filter.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/http_client_filter.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/iomgr/endpoint_pair.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_ssl+poll.c b/test/core/end2end/fixtures/h2_ssl+poll.c index 4c3bc64197..e93b4361ac 100644 --- a/test/core/end2end/fixtures/h2_ssl+poll.c +++ b/test/core/end2end/fixtures/h2_ssl+poll.c @@ -40,12 +40,12 @@ #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/iomgr/pollset_posix.h" -#include "src/core/security/credentials.h" -#include "src/core/support/env.h" -#include "src/core/support/string.h" -#include "src/core/support/tmpfile.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/iomgr/pollset_posix.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/support/tmpfile.h" #include "test/core/end2end/data/ssl_test_data.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_ssl.c b/test/core/end2end/fixtures/h2_ssl.c index 6a4e8dcb37..fecd03f6a7 100644 --- a/test/core/end2end/fixtures/h2_ssl.c +++ b/test/core/end2end/fixtures/h2_ssl.c @@ -40,11 +40,11 @@ #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/security/credentials.h" -#include "src/core/support/env.h" -#include "src/core/support/string.h" -#include "src/core/support/tmpfile.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/support/tmpfile.h" #include "test/core/end2end/data/ssl_test_data.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_ssl_proxy.c b/test/core/end2end/fixtures/h2_ssl_proxy.c index f5fcb91812..bfbc735742 100644 --- a/test/core/end2end/fixtures/h2_ssl_proxy.c +++ b/test/core/end2end/fixtures/h2_ssl_proxy.c @@ -40,11 +40,11 @@ #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/security/credentials.h" -#include "src/core/support/env.h" -#include "src/core/support/string.h" -#include "src/core/support/tmpfile.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/support/tmpfile.h" #include "test/core/end2end/data/ssl_test_data.h" #include "test/core/end2end/fixtures/proxy.h" #include "test/core/util/port.h" diff --git a/test/core/end2end/fixtures/h2_uds+poll.c b/test/core/end2end/fixtures/h2_uds+poll.c index c3a855ff88..e431ef37ed 100644 --- a/test/core/end2end/fixtures/h2_uds+poll.c +++ b/test/core/end2end/fixtures/h2_uds+poll.c @@ -45,14 +45,14 @@ #include #include -#include "src/core/channel/client_channel.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/iomgr/pollset_posix.h" -#include "src/core/support/string.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/iomgr/pollset_posix.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/fixtures/h2_uds.c b/test/core/end2end/fixtures/h2_uds.c index 3228c055a0..1bdcdef8de 100644 --- a/test/core/end2end/fixtures/h2_uds.c +++ b/test/core/end2end/fixtures/h2_uds.c @@ -44,13 +44,13 @@ #include #include #include -#include "src/core/channel/client_channel.h" -#include "src/core/channel/connected_channel.h" -#include "src/core/channel/http_server_filter.h" -#include "src/core/support/string.h" -#include "src/core/surface/channel.h" -#include "src/core/surface/server.h" -#include "src/core/transport/chttp2_transport.h" +#include "src/core/lib/channel/client_channel.h" +#include "src/core/lib/channel/connected_channel.h" +#include "src/core/lib/channel/http_server_filter.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/surface/server.h" +#include "src/core/lib/transport/chttp2_transport.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/end2end/tests/bad_hostname.c b/test/core/end2end/tests/bad_hostname.c index fe7a275244..df3f6be431 100644 --- a/test/core/end2end/tests/bad_hostname.c +++ b/test/core/end2end/tests/bad_hostname.c @@ -42,7 +42,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include "test/core/end2end/cq_verifier.h" enum { TIMEOUT = 200000 }; diff --git a/test/core/end2end/tests/call_creds.c b/test/core/end2end/tests/call_creds.c index 417f7e82bd..f749a60979 100644 --- a/test/core/end2end/tests/call_creds.c +++ b/test/core/end2end/tests/call_creds.c @@ -42,8 +42,8 @@ #include #include #include -#include "src/core/security/credentials.h" -#include "src/core/support/string.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/support/string.h" #include "test/core/end2end/cq_verifier.h" static const char iam_token[] = "token"; diff --git a/test/core/end2end/tests/cancel_with_status.c b/test/core/end2end/tests/cancel_with_status.c index 135bdf026c..e5a1556019 100644 --- a/test/core/end2end/tests/cancel_with_status.c +++ b/test/core/end2end/tests/cancel_with_status.c @@ -42,7 +42,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include "test/core/end2end/cq_verifier.h" enum { TIMEOUT = 200000 }; diff --git a/test/core/end2end/tests/compressed_payload.c b/test/core/end2end/tests/compressed_payload.c index c9092e3394..9c258858cb 100644 --- a/test/core/end2end/tests/compressed_payload.c +++ b/test/core/end2end/tests/compressed_payload.c @@ -43,9 +43,9 @@ #include #include -#include "src/core/channel/channel_args.h" -#include "src/core/channel/compress_filter.h" -#include "src/core/surface/call_test_only.h" +#include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/channel/compress_filter.h" +#include "src/core/lib/surface/call_test_only.h" #include "test/core/end2end/cq_verifier.h" enum { TIMEOUT = 200000 }; diff --git a/test/core/end2end/tests/default_host.c b/test/core/end2end/tests/default_host.c index 5455428144..576d81e395 100644 --- a/test/core/end2end/tests/default_host.c +++ b/test/core/end2end/tests/default_host.c @@ -42,7 +42,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include "test/core/end2end/cq_verifier.h" enum { TIMEOUT = 200000 }; diff --git a/test/core/end2end/tests/empty_batch.c b/test/core/end2end/tests/empty_batch.c index 53b5ca5e6b..7f56313fa0 100644 --- a/test/core/end2end/tests/empty_batch.c +++ b/test/core/end2end/tests/empty_batch.c @@ -42,7 +42,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include "test/core/end2end/cq_verifier.h" enum { TIMEOUT = 200000 }; diff --git a/test/core/end2end/tests/high_initial_seqno.c b/test/core/end2end/tests/high_initial_seqno.c index 72007821c8..2196fbd343 100644 --- a/test/core/end2end/tests/high_initial_seqno.c +++ b/test/core/end2end/tests/high_initial_seqno.c @@ -44,7 +44,7 @@ #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include "test/core/end2end/cq_verifier.h" enum { TIMEOUT = 200000 }; diff --git a/test/core/end2end/tests/hpack_size.c b/test/core/end2end/tests/hpack_size.c index 189131870e..2774e50627 100644 --- a/test/core/end2end/tests/hpack_size.c +++ b/test/core/end2end/tests/hpack_size.c @@ -44,7 +44,7 @@ #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include "test/core/end2end/cq_verifier.h" static void *tag(intptr_t t) { return (void *)t; } diff --git a/test/core/end2end/tests/negative_deadline.c b/test/core/end2end/tests/negative_deadline.c index 5de82c9795..e5031af59a 100644 --- a/test/core/end2end/tests/negative_deadline.c +++ b/test/core/end2end/tests/negative_deadline.c @@ -42,7 +42,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include "test/core/end2end/cq_verifier.h" enum { TIMEOUT = 200000 }; diff --git a/test/core/end2end/tests/registered_call.c b/test/core/end2end/tests/registered_call.c index 4051ded1f8..09f452f6e5 100644 --- a/test/core/end2end/tests/registered_call.c +++ b/test/core/end2end/tests/registered_call.c @@ -42,7 +42,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include "test/core/end2end/cq_verifier.h" enum { TIMEOUT = 200000 }; diff --git a/test/core/end2end/tests/request_with_flags.c b/test/core/end2end/tests/request_with_flags.c index f480009f00..433622e2da 100644 --- a/test/core/end2end/tests/request_with_flags.c +++ b/test/core/end2end/tests/request_with_flags.c @@ -41,7 +41,7 @@ #include #include #include -#include "src/core/transport/byte_stream.h" +#include "src/core/lib/transport/byte_stream.h" #include "test/core/end2end/cq_verifier.h" enum { TIMEOUT = 200000 }; diff --git a/test/core/end2end/tests/server_finishes_request.c b/test/core/end2end/tests/server_finishes_request.c index a7d1661f56..d3ac2d5d61 100644 --- a/test/core/end2end/tests/server_finishes_request.c +++ b/test/core/end2end/tests/server_finishes_request.c @@ -42,7 +42,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include "test/core/end2end/cq_verifier.h" enum { TIMEOUT = 200000 }; diff --git a/test/core/end2end/tests/simple_request.c b/test/core/end2end/tests/simple_request.c index a8ed79330d..bc634ef83a 100644 --- a/test/core/end2end/tests/simple_request.c +++ b/test/core/end2end/tests/simple_request.c @@ -42,7 +42,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include "test/core/end2end/cq_verifier.h" enum { TIMEOUT = 200000 }; diff --git a/test/core/fling/client.c b/test/core/fling/client.c index b36aef3093..6a4eb1c6e3 100644 --- a/test/core/fling/client.c +++ b/test/core/fling/client.c @@ -41,7 +41,7 @@ #include #include #include -#include "src/core/profiling/timers.h" +#include "src/core/lib/profiling/timers.h" #include "test/core/util/grpc_profiler.h" #include "test/core/util/test_config.h" diff --git a/test/core/fling/fling_stream_test.c b/test/core/fling/fling_stream_test.c index ff3d919b05..2807504976 100644 --- a/test/core/fling/fling_stream_test.c +++ b/test/core/fling/fling_stream_test.c @@ -47,7 +47,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include "test/core/util/port.h" int main(int argc, char **argv) { diff --git a/test/core/fling/fling_test.c b/test/core/fling/fling_test.c index 4e16b7f1b4..46456a2901 100644 --- a/test/core/fling/fling_test.c +++ b/test/core/fling/fling_test.c @@ -38,7 +38,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include "test/core/util/port.h" int main(int argc, char **argv) { diff --git a/test/core/fling/server.c b/test/core/fling/server.c index 42be20e42d..fd446f1128 100644 --- a/test/core/fling/server.c +++ b/test/core/fling/server.c @@ -49,7 +49,7 @@ #include #include #include -#include "src/core/profiling/timers.h" +#include "src/core/lib/profiling/timers.h" #include "test/core/end2end/data/ssl_test_data.h" #include "test/core/util/grpc_profiler.h" #include "test/core/util/port.h" diff --git a/test/core/http/format_request_test.c b/test/core/http/format_request_test.c index 5e2b709f89..a676420b70 100644 --- a/test/core/http/format_request_test.c +++ b/test/core/http/format_request_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/http/format_request.h" +#include "src/core/lib/http/format_request.h" #include diff --git a/test/core/http/httpcli_test.c b/test/core/http/httpcli_test.c index bdb7a02e9b..1fdbcd0800 100644 --- a/test/core/http/httpcli_test.c +++ b/test/core/http/httpcli_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/http/httpcli.h" +#include "src/core/lib/http/httpcli.h" #include @@ -41,7 +41,7 @@ #include #include #include -#include "src/core/iomgr/iomgr.h" +#include "src/core/lib/iomgr/iomgr.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/http/httpscli_test.c b/test/core/http/httpscli_test.c index 21845b6a8e..71db3e72bf 100644 --- a/test/core/http/httpscli_test.c +++ b/test/core/http/httpscli_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/http/httpcli.h" +#include "src/core/lib/http/httpcli.h" #include @@ -41,7 +41,7 @@ #include #include #include -#include "src/core/iomgr/iomgr.h" +#include "src/core/lib/iomgr/iomgr.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/http/parser_test.c b/test/core/http/parser_test.c index 338a301534..eeb4de7f30 100644 --- a/test/core/http/parser_test.c +++ b/test/core/http/parser_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/http/parser.h" +#include "src/core/lib/http/parser.h" #include #include diff --git a/test/core/iomgr/endpoint_pair_test.c b/test/core/iomgr/endpoint_pair_test.c index c3a91088a5..a91a9a7084 100644 --- a/test/core/iomgr/endpoint_pair_test.c +++ b/test/core/iomgr/endpoint_pair_test.c @@ -31,14 +31,14 @@ * */ -#include "src/core/iomgr/tcp_posix.h" +#include "src/core/lib/iomgr/tcp_posix.h" #include #include #include #include #include -#include "src/core/iomgr/endpoint_pair.h" +#include "src/core/lib/iomgr/endpoint_pair.h" #include "test/core/iomgr/endpoint_tests.h" #include "test/core/util/test_config.h" diff --git a/test/core/iomgr/endpoint_tests.h b/test/core/iomgr/endpoint_tests.h index 8ea47e345c..c7542a03e3 100644 --- a/test/core/iomgr/endpoint_tests.h +++ b/test/core/iomgr/endpoint_tests.h @@ -36,7 +36,7 @@ #include -#include "src/core/iomgr/endpoint.h" +#include "src/core/lib/iomgr/endpoint.h" typedef struct grpc_endpoint_test_config grpc_endpoint_test_config; typedef struct grpc_endpoint_test_fixture grpc_endpoint_test_fixture; diff --git a/test/core/iomgr/fd_conservation_posix_test.c b/test/core/iomgr/fd_conservation_posix_test.c index c38f509b16..aae94e71b2 100644 --- a/test/core/iomgr/fd_conservation_posix_test.c +++ b/test/core/iomgr/fd_conservation_posix_test.c @@ -35,8 +35,8 @@ #include -#include "src/core/iomgr/endpoint_pair.h" -#include "src/core/iomgr/iomgr.h" +#include "src/core/lib/iomgr/endpoint_pair.h" +#include "src/core/lib/iomgr/iomgr.h" #include "test/core/util/test_config.h" int main(int argc, char **argv) { diff --git a/test/core/iomgr/fd_posix_test.c b/test/core/iomgr/fd_posix_test.c index 99689ebcc3..203e1e3899 100644 --- a/test/core/iomgr/fd_posix_test.c +++ b/test/core/iomgr/fd_posix_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/fd_posix.h" +#include "src/core/lib/iomgr/fd_posix.h" #include #include @@ -50,7 +50,7 @@ #include #include -#include "src/core/iomgr/pollset_posix.h" +#include "src/core/lib/iomgr/pollset_posix.h" #include "test/core/util/test_config.h" static gpr_mu *g_mu; diff --git a/test/core/iomgr/resolve_address_test.c b/test/core/iomgr/resolve_address_test.c index b2a09978e6..7aec91a85e 100644 --- a/test/core/iomgr/resolve_address_test.c +++ b/test/core/iomgr/resolve_address_test.c @@ -31,11 +31,11 @@ * */ -#include "src/core/iomgr/resolve_address.h" +#include "src/core/lib/iomgr/resolve_address.h" #include #include #include -#include "src/core/iomgr/executor.h" +#include "src/core/lib/iomgr/executor.h" #include "test/core/util/test_config.h" static gpr_timespec test_deadline(void) { diff --git a/test/core/iomgr/sockaddr_utils_test.c b/test/core/iomgr/sockaddr_utils_test.c index a7b57c1466..a330314443 100644 --- a/test/core/iomgr/sockaddr_utils_test.c +++ b/test/core/iomgr/sockaddr_utils_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/sockaddr_utils.h" +#include "src/core/lib/iomgr/sockaddr_utils.h" #include #include diff --git a/test/core/iomgr/socket_utils_test.c b/test/core/iomgr/socket_utils_test.c index 58c3fbc0ae..85c027a978 100644 --- a/test/core/iomgr/socket_utils_test.c +++ b/test/core/iomgr/socket_utils_test.c @@ -32,7 +32,7 @@ */ #include -#include "src/core/iomgr/socket_utils_posix.h" +#include "src/core/lib/iomgr/socket_utils_posix.h" #include #include diff --git a/test/core/iomgr/tcp_client_posix_test.c b/test/core/iomgr/tcp_client_posix_test.c index 746dfd85be..d798bf241d 100644 --- a/test/core/iomgr/tcp_client_posix_test.c +++ b/test/core/iomgr/tcp_client_posix_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/tcp_client.h" +#include "src/core/lib/iomgr/tcp_client.h" #include #include @@ -44,9 +44,9 @@ #include #include -#include "src/core/iomgr/iomgr.h" -#include "src/core/iomgr/socket_utils_posix.h" -#include "src/core/iomgr/timer.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/iomgr/socket_utils_posix.h" +#include "src/core/lib/iomgr/timer.h" #include "test/core/util/test_config.h" static grpc_pollset_set *g_pollset_set; diff --git a/test/core/iomgr/tcp_posix_test.c b/test/core/iomgr/tcp_posix_test.c index 4351642ab6..79f18c6d7a 100644 --- a/test/core/iomgr/tcp_posix_test.c +++ b/test/core/iomgr/tcp_posix_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/tcp_posix.h" +#include "src/core/lib/iomgr/tcp_posix.h" #include #include diff --git a/test/core/iomgr/tcp_server_posix_test.c b/test/core/iomgr/tcp_server_posix_test.c index 7933468355..cde147d30e 100644 --- a/test/core/iomgr/tcp_server_posix_test.c +++ b/test/core/iomgr/tcp_server_posix_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/tcp_server.h" +#include "src/core/lib/iomgr/tcp_server.h" #include #include @@ -45,8 +45,8 @@ #include #include -#include "src/core/iomgr/iomgr.h" -#include "src/core/iomgr/sockaddr_utils.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/iomgr/sockaddr_utils.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/iomgr/time_averaged_stats_test.c b/test/core/iomgr/time_averaged_stats_test.c index cb006d152a..72f8559d66 100644 --- a/test/core/iomgr/time_averaged_stats_test.c +++ b/test/core/iomgr/time_averaged_stats_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/time_averaged_stats.h" +#include "src/core/lib/iomgr/time_averaged_stats.h" #include diff --git a/test/core/iomgr/timer_heap_test.c b/test/core/iomgr/timer_heap_test.c index dd23a99520..d230c831ca 100644 --- a/test/core/iomgr/timer_heap_test.c +++ b/test/core/iomgr/timer_heap_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/timer_heap.h" +#include "src/core/lib/iomgr/timer_heap.h" #include #include diff --git a/test/core/iomgr/timer_list_test.c b/test/core/iomgr/timer_list_test.c index 955bf44bb6..0333a75059 100644 --- a/test/core/iomgr/timer_list_test.c +++ b/test/core/iomgr/timer_list_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/timer.h" +#include "src/core/lib/iomgr/timer.h" #include diff --git a/test/core/iomgr/udp_server_test.c b/test/core/iomgr/udp_server_test.c index 042e936456..0c55ef08b4 100644 --- a/test/core/iomgr/udp_server_test.c +++ b/test/core/iomgr/udp_server_test.c @@ -31,13 +31,13 @@ * */ -#include "src/core/iomgr/udp_server.h" +#include "src/core/lib/iomgr/udp_server.h" #include #include #include #include -#include "src/core/iomgr/iomgr.h" -#include "src/core/iomgr/pollset_posix.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/iomgr/pollset_posix.h" #include "test/core/util/test_config.h" #include diff --git a/test/core/iomgr/workqueue_test.c b/test/core/iomgr/workqueue_test.c index 8a1faf6303..2d9b5d0d55 100644 --- a/test/core/iomgr/workqueue_test.c +++ b/test/core/iomgr/workqueue_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/iomgr/workqueue.h" +#include "src/core/lib/iomgr/workqueue.h" #include #include diff --git a/test/core/json/json_rewrite.c b/test/core/json/json_rewrite.c index 0c615a9975..c43c6e2589 100644 --- a/test/core/json/json_rewrite.c +++ b/test/core/json/json_rewrite.c @@ -38,8 +38,8 @@ #include #include -#include "src/core/json/json_reader.h" -#include "src/core/json/json_writer.h" +#include "src/core/lib/json/json_reader.h" +#include "src/core/lib/json/json_writer.h" typedef struct json_writer_userdata { FILE *out; } json_writer_userdata; diff --git a/test/core/json/json_rewrite_test.c b/test/core/json/json_rewrite_test.c index 1916d4b86c..33fc98ed74 100644 --- a/test/core/json/json_rewrite_test.c +++ b/test/core/json/json_rewrite_test.c @@ -39,8 +39,8 @@ #include #include "test/core/util/test_config.h" -#include "src/core/json/json_reader.h" -#include "src/core/json/json_writer.h" +#include "src/core/lib/json/json_reader.h" +#include "src/core/lib/json/json_writer.h" typedef struct json_writer_userdata { FILE *cmp; } json_writer_userdata; diff --git a/test/core/json/json_stream_error_test.c b/test/core/json/json_stream_error_test.c index 3b07fcd38e..630e1b03df 100644 --- a/test/core/json/json_stream_error_test.c +++ b/test/core/json/json_stream_error_test.c @@ -39,8 +39,8 @@ #include #include "test/core/util/test_config.h" -#include "src/core/json/json_reader.h" -#include "src/core/json/json_writer.h" +#include "src/core/lib/json/json_reader.h" +#include "src/core/lib/json/json_writer.h" static int g_string_clear_once = 0; diff --git a/test/core/json/json_test.c b/test/core/json/json_test.c index e9b81e2021..2a007627f3 100644 --- a/test/core/json/json_test.c +++ b/test/core/json/json_test.c @@ -37,8 +37,8 @@ #include #include #include -#include "src/core/json/json.h" -#include "src/core/support/string.h" +#include "src/core/lib/json/json.h" +#include "src/core/lib/support/string.h" #include "test/core/util/test_config.h" diff --git a/test/core/network_benchmarks/low_level_ping_pong.c b/test/core/network_benchmarks/low_level_ping_pong.c index 7ed3372d5d..b8c6954e38 100644 --- a/test/core/network_benchmarks/low_level_ping_pong.c +++ b/test/core/network_benchmarks/low_level_ping_pong.c @@ -55,7 +55,7 @@ #include #include #include -#include "src/core/iomgr/socket_utils_posix.h" +#include "src/core/lib/iomgr/socket_utils_posix.h" typedef struct fd_pair { int read_fd; diff --git a/test/core/profiling/timers_test.c b/test/core/profiling/timers_test.c index 7070fe465f..284589af1e 100644 --- a/test/core/profiling/timers_test.c +++ b/test/core/profiling/timers_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/profiling/timers.h" +#include "src/core/lib/profiling/timers.h" #include #include "test/core/util/test_config.h" diff --git a/test/core/security/auth_context_test.c b/test/core/security/auth_context_test.c index d091c7e7e6..d1ead16235 100644 --- a/test/core/security/auth_context_test.c +++ b/test/core/security/auth_context_test.c @@ -33,8 +33,8 @@ #include -#include "src/core/security/security_context.h" -#include "src/core/support/string.h" +#include "src/core/lib/security/security_context.h" +#include "src/core/lib/support/string.h" #include "test/core/util/test_config.h" #include diff --git a/test/core/security/b64_test.c b/test/core/security/b64_test.c index 772514e1fd..ab15df2c21 100644 --- a/test/core/security/b64_test.c +++ b/test/core/security/b64_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/security/b64.h" +#include "src/core/lib/security/b64.h" #include diff --git a/test/core/security/create_jwt.c b/test/core/security/create_jwt.c index 4c0cf436ee..3416de7254 100644 --- a/test/core/security/create_jwt.c +++ b/test/core/security/create_jwt.c @@ -34,9 +34,9 @@ #include #include -#include "src/core/security/credentials.h" -#include "src/core/security/json_token.h" -#include "src/core/support/load_file.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/security/json_token.h" +#include "src/core/lib/support/load_file.h" #include #include diff --git a/test/core/security/credentials_test.c b/test/core/security/credentials_test.c index 3a6b9696ab..e741e3656f 100644 --- a/test/core/security/credentials_test.c +++ b/test/core/security/credentials_test.c @@ -33,7 +33,7 @@ #include -#include "src/core/security/credentials.h" +#include "src/core/lib/security/credentials.h" #include #include @@ -44,11 +44,11 @@ #include #include -#include "src/core/http/httpcli.h" -#include "src/core/security/json_token.h" -#include "src/core/support/env.h" -#include "src/core/support/string.h" -#include "src/core/support/tmpfile.h" +#include "src/core/lib/http/httpcli.h" +#include "src/core/lib/security/json_token.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/support/tmpfile.h" #include "test/core/util/test_config.h" /* -- Mock channel credentials. -- */ diff --git a/test/core/security/fetch_oauth2.c b/test/core/security/fetch_oauth2.c index 87b54f1a0c..1f4e18005e 100644 --- a/test/core/security/fetch_oauth2.c +++ b/test/core/security/fetch_oauth2.c @@ -42,8 +42,8 @@ #include #include -#include "src/core/security/credentials.h" -#include "src/core/support/load_file.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/support/load_file.h" #include "test/core/security/oauth2_utils.h" static grpc_call_credentials *create_refresh_token_creds( diff --git a/test/core/security/json_token_test.c b/test/core/security/json_token_test.c index 4d80c16fb9..460d5299f0 100644 --- a/test/core/security/json_token_test.c +++ b/test/core/security/json_token_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/security/json_token.h" +#include "src/core/lib/security/json_token.h" #include #include @@ -41,8 +41,8 @@ #include #include -#include "src/core/json/json.h" -#include "src/core/security/b64.h" +#include "src/core/lib/json/json.h" +#include "src/core/lib/security/b64.h" #include "test/core/util/test_config.h" /* This JSON key was generated with the GCE console and revoked immediately. diff --git a/test/core/security/jwt_verifier_test.c b/test/core/security/jwt_verifier_test.c index d2f8d1d182..c57f4d72ee 100644 --- a/test/core/security/jwt_verifier_test.c +++ b/test/core/security/jwt_verifier_test.c @@ -31,13 +31,13 @@ * */ -#include "src/core/security/jwt_verifier.h" +#include "src/core/lib/security/jwt_verifier.h" #include -#include "src/core/http/httpcli.h" -#include "src/core/security/b64.h" -#include "src/core/security/json_token.h" +#include "src/core/lib/http/httpcli.h" +#include "src/core/lib/security/b64.h" +#include "src/core/lib/security/json_token.h" #include "test/core/util/test_config.h" #include diff --git a/test/core/security/oauth2_utils.c b/test/core/security/oauth2_utils.c index 9b70afffe1..52259e63af 100644 --- a/test/core/security/oauth2_utils.c +++ b/test/core/security/oauth2_utils.c @@ -42,7 +42,7 @@ #include #include -#include "src/core/security/credentials.h" +#include "src/core/lib/security/credentials.h" typedef struct { gpr_mu *mu; diff --git a/test/core/security/oauth2_utils.h b/test/core/security/oauth2_utils.h index b35fe7987f..eff98270c8 100644 --- a/test/core/security/oauth2_utils.h +++ b/test/core/security/oauth2_utils.h @@ -34,7 +34,7 @@ #ifndef GRPC_TEST_CORE_SECURITY_OAUTH2_UTILS_H #define GRPC_TEST_CORE_SECURITY_OAUTH2_UTILS_H -#include "src/core/security/credentials.h" +#include "src/core/lib/security/credentials.h" #ifdef __cplusplus extern "C" { diff --git a/test/core/security/print_google_default_creds_token.c b/test/core/security/print_google_default_creds_token.c index 09673f362c..49812f7f3e 100644 --- a/test/core/security/print_google_default_creds_token.c +++ b/test/core/security/print_google_default_creds_token.c @@ -42,8 +42,8 @@ #include #include -#include "src/core/security/credentials.h" -#include "src/core/support/string.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/support/string.h" typedef struct { gpr_mu *mu; diff --git a/test/core/security/secure_endpoint_test.c b/test/core/security/secure_endpoint_test.c index 0e8c38a53e..f6884ec1ba 100644 --- a/test/core/security/secure_endpoint_test.c +++ b/test/core/security/secure_endpoint_test.c @@ -39,10 +39,10 @@ #include #include #include -#include "src/core/iomgr/endpoint_pair.h" -#include "src/core/iomgr/iomgr.h" -#include "src/core/security/secure_endpoint.h" -#include "src/core/tsi/fake_transport_security.h" +#include "src/core/lib/iomgr/endpoint_pair.h" +#include "src/core/lib/iomgr/iomgr.h" +#include "src/core/lib/security/secure_endpoint.h" +#include "src/core/lib/tsi/fake_transport_security.h" #include "test/core/util/test_config.h" static gpr_mu *g_mu; diff --git a/test/core/security/security_connector_test.c b/test/core/security/security_connector_test.c index 31a56ea723..b080343e3f 100644 --- a/test/core/security/security_connector_test.c +++ b/test/core/security/security_connector_test.c @@ -40,13 +40,13 @@ #include #include -#include "src/core/security/security_connector.h" -#include "src/core/security/security_context.h" -#include "src/core/support/env.h" -#include "src/core/support/string.h" -#include "src/core/support/tmpfile.h" -#include "src/core/tsi/ssl_transport_security.h" -#include "src/core/tsi/transport_security.h" +#include "src/core/lib/security/security_connector.h" +#include "src/core/lib/security/security_context.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/support/tmpfile.h" +#include "src/core/lib/tsi/ssl_transport_security.h" +#include "src/core/lib/tsi/transport_security.h" #include "test/core/util/test_config.h" static int check_transport_security_type(const grpc_auth_context *ctx) { diff --git a/test/core/security/verify_jwt.c b/test/core/security/verify_jwt.c index eb86589681..c08e03d9d7 100644 --- a/test/core/security/verify_jwt.c +++ b/test/core/security/verify_jwt.c @@ -42,7 +42,7 @@ #include #include -#include "src/core/security/jwt_verifier.h" +#include "src/core/lib/security/jwt_verifier.h" typedef struct { grpc_pollset *pollset; diff --git a/test/core/statistics/census_log_tests.c b/test/core/statistics/census_log_tests.c index 7cbb0c022b..fef8e9ed48 100644 --- a/test/core/statistics/census_log_tests.c +++ b/test/core/statistics/census_log_tests.c @@ -31,7 +31,7 @@ * */ -#include "src/core/statistics/census_log.h" +#include "src/core/lib/statistics/census_log.h" #include #include #include diff --git a/test/core/statistics/census_stub_test.c b/test/core/statistics/census_stub_test.c index e734a34f55..df5d25b678 100644 --- a/test/core/statistics/census_stub_test.c +++ b/test/core/statistics/census_stub_test.c @@ -36,8 +36,8 @@ #include #include -#include "src/core/statistics/census_interface.h" -#include "src/core/statistics/census_rpc_stats.h" +#include "src/core/lib/statistics/census_interface.h" +#include "src/core/lib/statistics/census_rpc_stats.h" #include "test/core/util/test_config.h" /* Tests census noop stubs in a simulated rpc flow */ diff --git a/test/core/statistics/hash_table_test.c b/test/core/statistics/hash_table_test.c index 7ff5bb77ad..903d297bb8 100644 --- a/test/core/statistics/hash_table_test.c +++ b/test/core/statistics/hash_table_test.c @@ -35,13 +35,13 @@ #include #include -#include "src/core/statistics/hash_table.h" +#include "src/core/lib/statistics/hash_table.h" #include #include #include -#include "src/core/support/murmur_hash.h" -#include "src/core/support/string.h" +#include "src/core/lib/support/murmur_hash.h" +#include "src/core/lib/support/string.h" #include "test/core/util/test_config.h" static uint64_t hash64(const void *k) { diff --git a/test/core/statistics/rpc_stats_test.c b/test/core/statistics/rpc_stats_test.c index 3ece3caaf3..dc2f70bbd4 100644 --- a/test/core/statistics/rpc_stats_test.c +++ b/test/core/statistics/rpc_stats_test.c @@ -39,9 +39,9 @@ #include #include #include -#include "src/core/statistics/census_interface.h" -#include "src/core/statistics/census_rpc_stats.h" -#include "src/core/statistics/census_tracing.h" +#include "src/core/lib/statistics/census_interface.h" +#include "src/core/lib/statistics/census_rpc_stats.h" +#include "src/core/lib/statistics/census_tracing.h" #include "test/core/util/test_config.h" /* Ensure all possible state transitions are called without causing problem */ diff --git a/test/core/statistics/trace_test.c b/test/core/statistics/trace_test.c index 2c64e89ddd..2cc3ddd36c 100644 --- a/test/core/statistics/trace_test.c +++ b/test/core/statistics/trace_test.c @@ -41,9 +41,9 @@ #include #include #include -#include "src/core/statistics/census_interface.h" -#include "src/core/statistics/census_tracing.h" -#include "src/core/statistics/census_tracing.h" +#include "src/core/lib/statistics/census_interface.h" +#include "src/core/lib/statistics/census_tracing.h" +#include "src/core/lib/statistics/census_tracing.h" #include "test/core/util/test_config.h" /* Ensure all possible state transitions are called without causing problem */ diff --git a/test/core/statistics/window_stats_test.c b/test/core/statistics/window_stats_test.c index 9ed7ee1fac..ed0d7bb94a 100644 --- a/test/core/statistics/window_stats_test.c +++ b/test/core/statistics/window_stats_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/statistics/window_stats.h" +#include "src/core/lib/statistics/window_stats.h" #include #include #include diff --git a/test/core/support/backoff_test.c b/test/core/support/backoff_test.c index 870b60b2d5..13cba7d750 100644 --- a/test/core/support/backoff_test.c +++ b/test/core/support/backoff_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/support/backoff.h" +#include "src/core/lib/support/backoff.h" #include diff --git a/test/core/support/env_test.c b/test/core/support/env_test.c index 69aebcc918..bd6a8bdf9d 100644 --- a/test/core/support/env_test.c +++ b/test/core/support/env_test.c @@ -37,8 +37,8 @@ #include #include -#include "src/core/support/env.h" -#include "src/core/support/string.h" +#include "src/core/lib/support/env.h" +#include "src/core/lib/support/string.h" #include "test/core/util/test_config.h" #define LOG_TEST_NAME(x) gpr_log(GPR_INFO, "%s", x) diff --git a/test/core/support/load_file_test.c b/test/core/support/load_file_test.c index a14fdc656e..6bc7b90058 100644 --- a/test/core/support/load_file_test.c +++ b/test/core/support/load_file_test.c @@ -38,9 +38,9 @@ #include #include -#include "src/core/support/load_file.h" -#include "src/core/support/string.h" -#include "src/core/support/tmpfile.h" +#include "src/core/lib/support/load_file.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/support/tmpfile.h" #include "test/core/util/test_config.h" #define LOG_TEST_NAME(x) gpr_log(GPR_INFO, "%s", x) diff --git a/test/core/support/murmur_hash_test.c b/test/core/support/murmur_hash_test.c index 562b9567e7..ef32719408 100644 --- a/test/core/support/murmur_hash_test.c +++ b/test/core/support/murmur_hash_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/support/murmur_hash.h" +#include "src/core/lib/support/murmur_hash.h" #include #include #include "test/core/util/test_config.h" diff --git a/test/core/support/stack_lockfree_test.c b/test/core/support/stack_lockfree_test.c index 0f49e6fa52..745157f701 100644 --- a/test/core/support/stack_lockfree_test.c +++ b/test/core/support/stack_lockfree_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/support/stack_lockfree.h" +#include "src/core/lib/support/stack_lockfree.h" #include diff --git a/test/core/support/string_test.c b/test/core/support/string_test.c index c1d0f12250..d5f8107f21 100644 --- a/test/core/support/string_test.c +++ b/test/core/support/string_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include #include diff --git a/test/core/surface/byte_buffer_reader_test.c b/test/core/surface/byte_buffer_reader_test.c index c8aacdb017..629bce9107 100644 --- a/test/core/surface/byte_buffer_reader_test.c +++ b/test/core/surface/byte_buffer_reader_test.c @@ -42,7 +42,7 @@ #include #include "test/core/util/test_config.h" -#include "src/core/compression/message_compress.h" +#include "src/core/lib/compression/message_compress.h" #include diff --git a/test/core/surface/channel_create_test.c b/test/core/surface/channel_create_test.c index 044e766473..95b4eaf093 100644 --- a/test/core/surface/channel_create_test.c +++ b/test/core/surface/channel_create_test.c @@ -33,7 +33,7 @@ #include #include -#include "src/core/client_config/resolver_registry.h" +#include "src/core/lib/client_config/resolver_registry.h" #include "test/core/util/test_config.h" void test_unknown_scheme_target(void) { diff --git a/test/core/surface/completion_queue_test.c b/test/core/surface/completion_queue_test.c index 4f534de0f6..fa9b363a6f 100644 --- a/test/core/surface/completion_queue_test.c +++ b/test/core/surface/completion_queue_test.c @@ -31,14 +31,14 @@ * */ -#include "src/core/surface/completion_queue.h" +#include "src/core/lib/surface/completion_queue.h" #include #include #include #include #include -#include "src/core/iomgr/iomgr.h" +#include "src/core/lib/iomgr/iomgr.h" #include "test/core/util/test_config.h" #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x) diff --git a/test/core/surface/lame_client_test.c b/test/core/surface/lame_client_test.c index 79e53cb422..310aa00343 100644 --- a/test/core/surface/lame_client_test.c +++ b/test/core/surface/lame_client_test.c @@ -36,10 +36,10 @@ #include #include #include -#include "src/core/channel/channel_stack.h" -#include "src/core/iomgr/closure.h" -#include "src/core/surface/channel.h" -#include "src/core/transport/transport.h" +#include "src/core/lib/channel/channel_stack.h" +#include "src/core/lib/iomgr/closure.h" +#include "src/core/lib/surface/channel.h" +#include "src/core/lib/transport/transport.h" #include "test/core/end2end/cq_verifier.h" #include "test/core/util/test_config.h" diff --git a/test/core/surface/secure_channel_create_test.c b/test/core/surface/secure_channel_create_test.c index f3e5fefaf0..eb710cba38 100644 --- a/test/core/surface/secure_channel_create_test.c +++ b/test/core/surface/secure_channel_create_test.c @@ -36,10 +36,10 @@ #include #include #include -#include "src/core/client_config/resolver_registry.h" -#include "src/core/security/credentials.h" -#include "src/core/security/security_connector.h" -#include "src/core/surface/channel.h" +#include "src/core/lib/client_config/resolver_registry.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/security/security_connector.h" +#include "src/core/lib/surface/channel.h" #include "test/core/util/test_config.h" void test_unknown_scheme_target(void) { diff --git a/test/core/surface/server_chttp2_test.c b/test/core/surface/server_chttp2_test.c index 84b345bb50..14eb1ff9dc 100644 --- a/test/core/surface/server_chttp2_test.c +++ b/test/core/surface/server_chttp2_test.c @@ -37,8 +37,8 @@ #include #include #include -#include "src/core/security/credentials.h" -#include "src/core/tsi/fake_transport_security.h" +#include "src/core/lib/security/credentials.h" +#include "src/core/lib/tsi/fake_transport_security.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/core/transport/chttp2/alpn_test.c b/test/core/transport/chttp2/alpn_test.c index 9a7d5ef0c3..0792073711 100644 --- a/test/core/transport/chttp2/alpn_test.c +++ b/test/core/transport/chttp2/alpn_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/alpn.h" +#include "src/core/lib/transport/chttp2/alpn.h" #include #include "test/core/util/test_config.h" diff --git a/test/core/transport/chttp2/bin_encoder_test.c b/test/core/transport/chttp2/bin_encoder_test.c index 815b03c535..fd798d88d5 100644 --- a/test/core/transport/chttp2/bin_encoder_test.c +++ b/test/core/transport/chttp2/bin_encoder_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/bin_encoder.h" +#include "src/core/lib/transport/chttp2/bin_encoder.h" #include @@ -41,7 +41,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" static int all_ok = 1; diff --git a/test/core/transport/chttp2/hpack_encoder_test.c b/test/core/transport/chttp2/hpack_encoder_test.c index f5de087bac..b23e999c52 100644 --- a/test/core/transport/chttp2/hpack_encoder_test.c +++ b/test/core/transport/chttp2/hpack_encoder_test.c @@ -31,16 +31,16 @@ * */ -#include "src/core/transport/chttp2/hpack_encoder.h" +#include "src/core/lib/transport/chttp2/hpack_encoder.h" #include #include #include #include -#include "src/core/support/string.h" -#include "src/core/transport/chttp2/hpack_parser.h" -#include "src/core/transport/metadata.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/transport/chttp2/hpack_parser.h" +#include "src/core/lib/transport/metadata.h" #include "test/core/util/parse_hexstring.h" #include "test/core/util/slice_splitter.h" #include "test/core/util/test_config.h" diff --git a/test/core/transport/chttp2/hpack_parser_test.c b/test/core/transport/chttp2/hpack_parser_test.c index 4456e197af..ab82fd4292 100644 --- a/test/core/transport/chttp2/hpack_parser_test.c +++ b/test/core/transport/chttp2/hpack_parser_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/hpack_parser.h" +#include "src/core/lib/transport/chttp2/hpack_parser.h" #include diff --git a/test/core/transport/chttp2/hpack_table_test.c b/test/core/transport/chttp2/hpack_table_test.c index 4c0fa2e2e7..fbacdc3ad6 100644 --- a/test/core/transport/chttp2/hpack_table_test.c +++ b/test/core/transport/chttp2/hpack_table_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/hpack_table.h" +#include "src/core/lib/transport/chttp2/hpack_table.h" #include #include @@ -41,7 +41,7 @@ #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include "test/core/util/test_config.h" #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x) diff --git a/test/core/transport/chttp2/status_conversion_test.c b/test/core/transport/chttp2/status_conversion_test.c index e2729a0a19..f3126cc520 100644 --- a/test/core/transport/chttp2/status_conversion_test.c +++ b/test/core/transport/chttp2/status_conversion_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/status_conversion.h" +#include "src/core/lib/transport/chttp2/status_conversion.h" #include #include "test/core/util/test_config.h" diff --git a/test/core/transport/chttp2/stream_map_test.c b/test/core/transport/chttp2/stream_map_test.c index 527d2fe0ae..971410337d 100644 --- a/test/core/transport/chttp2/stream_map_test.c +++ b/test/core/transport/chttp2/stream_map_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/stream_map.h" +#include "src/core/lib/transport/chttp2/stream_map.h" #include #include "test/core/util/test_config.h" diff --git a/test/core/transport/chttp2/timeout_encoding_test.c b/test/core/transport/chttp2/timeout_encoding_test.c index b7dd60e9b1..9a91a14433 100644 --- a/test/core/transport/chttp2/timeout_encoding_test.c +++ b/test/core/transport/chttp2/timeout_encoding_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/timeout_encoding.h" +#include "src/core/lib/transport/chttp2/timeout_encoding.h" #include #include @@ -40,7 +40,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" #include "test/core/util/test_config.h" #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x) diff --git a/test/core/transport/chttp2/varint_test.c b/test/core/transport/chttp2/varint_test.c index f06116a731..f8cc4ab627 100644 --- a/test/core/transport/chttp2/varint_test.c +++ b/test/core/transport/chttp2/varint_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/chttp2/varint.h" +#include "src/core/lib/transport/chttp2/varint.h" #include #include diff --git a/test/core/transport/connectivity_state_test.c b/test/core/transport/connectivity_state_test.c index 4b2d0aa44a..b310d4dc00 100644 --- a/test/core/transport/connectivity_state_test.c +++ b/test/core/transport/connectivity_state_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/connectivity_state.h" +#include "src/core/lib/transport/connectivity_state.h" #include diff --git a/test/core/transport/metadata_test.c b/test/core/transport/metadata_test.c index 928fba7f45..5270d8f4d4 100644 --- a/test/core/transport/metadata_test.c +++ b/test/core/transport/metadata_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/transport/metadata.h" +#include "src/core/lib/transport/metadata.h" #include @@ -40,8 +40,8 @@ #include #include -#include "src/core/support/string.h" -#include "src/core/transport/chttp2/bin_encoder.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/transport/chttp2/bin_encoder.h" #include "test/core/util/test_config.h" #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x) diff --git a/test/core/tsi/transport_security_test.c b/test/core/tsi/transport_security_test.c index 667d3f0349..49b5b8b5f2 100644 --- a/test/core/tsi/transport_security_test.c +++ b/test/core/tsi/transport_security_test.c @@ -31,7 +31,7 @@ * */ -#include "src/core/tsi/transport_security.h" +#include "src/core/lib/tsi/transport_security.h" #include @@ -42,9 +42,9 @@ #include -#include "src/core/support/string.h" -#include "src/core/tsi/fake_transport_security.h" -#include "src/core/tsi/ssl_transport_security.h" +#include "src/core/lib/support/string.h" +#include "src/core/lib/tsi/fake_transport_security.h" +#include "src/core/lib/tsi/ssl_transport_security.h" #include "test/core/util/test_config.h" typedef struct { diff --git a/test/core/util/port_posix.c b/test/core/util/port_posix.c index d211016267..fea7e52b09 100644 --- a/test/core/util/port_posix.c +++ b/test/core/util/port_posix.c @@ -49,8 +49,8 @@ #include #include -#include "src/core/http/httpcli.h" -#include "src/core/support/env.h" +#include "src/core/lib/http/httpcli.h" +#include "src/core/lib/support/env.h" #include "test/core/util/port_server_client.h" #define NUM_RANDOM_PORTS_TO_PICK 100 diff --git a/test/core/util/port_server_client.c b/test/core/util/port_server_client.c index c7b9d63109..ea01b46838 100644 --- a/test/core/util/port_server_client.c +++ b/test/core/util/port_server_client.c @@ -47,7 +47,7 @@ #include #include -#include "src/core/http/httpcli.h" +#include "src/core/lib/http/httpcli.h" typedef struct freereq { gpr_mu *mu; diff --git a/test/core/util/port_windows.c b/test/core/util/port_windows.c index 4cbedc0aa6..081782d295 100644 --- a/test/core/util/port_windows.c +++ b/test/core/util/port_windows.c @@ -46,9 +46,9 @@ #include #include -#include "src/core/http/httpcli.h" -#include "src/core/iomgr/sockaddr_utils.h" -#include "src/core/support/env.h" +#include "src/core/lib/http/httpcli.h" +#include "src/core/lib/iomgr/sockaddr_utils.h" +#include "src/core/lib/support/env.h" #include "test/core/util/port_server_client.h" #define NUM_RANDOM_PORTS_TO_PICK 100 diff --git a/test/core/util/reconnect_server.c b/test/core/util/reconnect_server.c index 57225aa8a3..0e7a486526 100644 --- a/test/core/util/reconnect_server.c +++ b/test/core/util/reconnect_server.c @@ -40,9 +40,9 @@ #include #include #include -#include "src/core/iomgr/endpoint.h" -#include "src/core/iomgr/sockaddr.h" -#include "src/core/iomgr/tcp_server.h" +#include "src/core/lib/iomgr/endpoint.h" +#include "src/core/lib/iomgr/sockaddr.h" +#include "src/core/lib/iomgr/tcp_server.h" #include "test/core/util/port.h" #include "test/core/util/test_tcp_server.h" diff --git a/test/core/util/test_config.c b/test/core/util/test_config.c index f408048fdf..7ffaa6fe27 100644 --- a/test/core/util/test_config.c +++ b/test/core/util/test_config.c @@ -39,7 +39,7 @@ #include #include #include -#include "src/core/support/string.h" +#include "src/core/lib/support/string.h" double g_fixture_slowdown_factor = 1.0; diff --git a/test/core/util/test_tcp_server.c b/test/core/util/test_tcp_server.c index ab379441d8..7703ec0039 100644 --- a/test/core/util/test_tcp_server.c +++ b/test/core/util/test_tcp_server.c @@ -40,9 +40,9 @@ #include #include #include -#include "src/core/iomgr/endpoint.h" -#include "src/core/iomgr/sockaddr.h" -#include "src/core/iomgr/tcp_server.h" +#include "src/core/lib/iomgr/endpoint.h" +#include "src/core/lib/iomgr/sockaddr.h" +#include "src/core/lib/iomgr/tcp_server.h" #include "test/core/util/port.h" static void on_server_destroyed(grpc_exec_ctx *exec_ctx, void *data, diff --git a/test/core/util/test_tcp_server.h b/test/core/util/test_tcp_server.h index 15fcb4fb87..7d1025f17a 100644 --- a/test/core/util/test_tcp_server.h +++ b/test/core/util/test_tcp_server.h @@ -35,7 +35,7 @@ #define GRPC_TEST_CORE_UTIL_TEST_TCP_SERVER_H #include -#include "src/core/iomgr/tcp_server.h" +#include "src/core/lib/iomgr/tcp_server.h" typedef struct test_tcp_server { grpc_tcp_server *tcp_server; diff --git a/test/cpp/common/auth_property_iterator_test.cc b/test/cpp/common/auth_property_iterator_test.cc index 4c6dd6039c..4b5cf02c69 100644 --- a/test/cpp/common/auth_property_iterator_test.cc +++ b/test/cpp/common/auth_property_iterator_test.cc @@ -38,7 +38,7 @@ #include "test/cpp/util/string_ref_helper.h" extern "C" { -#include "src/core/security/security_context.h" +#include "src/core/lib/security/security_context.h" } using ::grpc::testing::ToString; diff --git a/test/cpp/common/secure_auth_context_test.cc b/test/cpp/common/secure_auth_context_test.cc index 123d4947e0..c421910cba 100644 --- a/test/cpp/common/secure_auth_context_test.cc +++ b/test/cpp/common/secure_auth_context_test.cc @@ -38,7 +38,7 @@ #include "test/cpp/util/string_ref_helper.h" extern "C" { -#include "src/core/security/security_context.h" +#include "src/core/lib/security/security_context.h" } using grpc::testing::ToString; diff --git a/test/cpp/end2end/async_end2end_test.cc b/test/cpp/end2end/async_end2end_test.cc index dc8c2bb6e5..d8aa4c0137 100644 --- a/test/cpp/end2end/async_end2end_test.cc +++ b/test/cpp/end2end/async_end2end_test.cc @@ -53,7 +53,7 @@ #include "test/cpp/util/string_ref_helper.h" #ifdef GPR_POSIX_SOCKET -#include "src/core/iomgr/pollset_posix.h" +#include "src/core/lib/iomgr/pollset_posix.h" #endif using grpc::testing::EchoRequest; diff --git a/test/cpp/end2end/end2end_test.cc b/test/cpp/end2end/end2end_test.cc index 4759818322..ff388c0341 100644 --- a/test/cpp/end2end/end2end_test.cc +++ b/test/cpp/end2end/end2end_test.cc @@ -48,7 +48,7 @@ #include #include -#include "src/core/security/credentials.h" +#include "src/core/lib/security/credentials.h" #include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h" #include "src/proto/grpc/testing/echo.grpc.pb.h" #include "test/core/util/port.h" diff --git a/test/cpp/end2end/shutdown_test.cc b/test/cpp/end2end/shutdown_test.cc index dbbda3ac51..62bb6b1b78 100644 --- a/test/cpp/end2end/shutdown_test.cc +++ b/test/cpp/end2end/shutdown_test.cc @@ -43,7 +43,7 @@ #include #include -#include "src/core/support/env.h" +#include "src/core/lib/support/env.h" #include "src/proto/grpc/testing/echo.grpc.pb.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/cpp/end2end/thread_stress_test.cc b/test/cpp/end2end/thread_stress_test.cc index 114d715baa..8760b8d28e 100644 --- a/test/cpp/end2end/thread_stress_test.cc +++ b/test/cpp/end2end/thread_stress_test.cc @@ -45,7 +45,7 @@ #include #include -#include "src/core/surface/api_trace.h" +#include "src/core/lib/surface/api_trace.h" #include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h" #include "src/proto/grpc/testing/echo.grpc.pb.h" #include "test/core/util/port.h" diff --git a/test/cpp/end2end/zookeeper_test.cc b/test/cpp/end2end/zookeeper_test.cc index bbf1b0edc1..f1b6ac2479 100644 --- a/test/cpp/end2end/zookeeper_test.cc +++ b/test/cpp/end2end/zookeeper_test.cc @@ -42,7 +42,7 @@ #include #include -#include "src/core/support/env.h" +#include "src/core/lib/support/env.h" #include "src/proto/grpc/testing/echo.grpc.pb.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/cpp/grpclb/grpclb_api_test.cc b/test/cpp/grpclb/grpclb_api_test.cc index bd4885fb4c..bc8219c1c7 100644 --- a/test/cpp/grpclb/grpclb_api_test.cc +++ b/test/cpp/grpclb/grpclb_api_test.cc @@ -34,7 +34,7 @@ #include #include -#include "src/core/client_config/lb_policies/load_balancer_api.h" +#include "src/core/lib/client_config/lb_policies/load_balancer_api.h" #include "src/proto/grpc/lb/v0/load_balancer.pb.h" // C++ version namespace grpc { diff --git a/test/cpp/interop/client_helper.h b/test/cpp/interop/client_helper.h index 0f77474139..622b96e4fb 100644 --- a/test/cpp/interop/client_helper.h +++ b/test/cpp/interop/client_helper.h @@ -38,7 +38,7 @@ #include -#include "src/core/surface/call_test_only.h" +#include "src/core/lib/surface/call_test_only.h" namespace grpc { namespace testing { diff --git a/test/cpp/interop/interop_client.cc b/test/cpp/interop/interop_client.cc index 514d4fa861..2fcd9f3951 100644 --- a/test/cpp/interop/interop_client.cc +++ b/test/cpp/interop/interop_client.cc @@ -46,7 +46,7 @@ #include #include -#include "src/core/transport/byte_stream.h" +#include "src/core/lib/transport/byte_stream.h" #include "src/proto/grpc/testing/empty.grpc.pb.h" #include "src/proto/grpc/testing/messages.grpc.pb.h" #include "src/proto/grpc/testing/test.grpc.pb.h" diff --git a/test/cpp/interop/interop_test.cc b/test/cpp/interop/interop_test.cc index f0fccf4615..f1fb3c9675 100644 --- a/test/cpp/interop/interop_test.cc +++ b/test/cpp/interop/interop_test.cc @@ -51,8 +51,8 @@ #include "test/core/util/port.h" extern "C" { -#include "src/core/iomgr/socket_utils_posix.h" -#include "src/core/support/string.h" +#include "src/core/lib/iomgr/socket_utils_posix.h" +#include "src/core/lib/support/string.h" } int test_client(const char* root, const char* host, int port) { diff --git a/test/cpp/interop/server_helper.cc b/test/cpp/interop/server_helper.cc index 9a284094f0..c6d891ad71 100644 --- a/test/cpp/interop/server_helper.cc +++ b/test/cpp/interop/server_helper.cc @@ -38,7 +38,7 @@ #include #include -#include "src/core/surface/call_test_only.h" +#include "src/core/lib/surface/call_test_only.h" #include "test/core/end2end/data/ssl_test_data.h" DECLARE_bool(use_tls); diff --git a/test/cpp/qps/client_sync.cc b/test/cpp/qps/client_sync.cc index 4284e07bd4..a1489d88e6 100644 --- a/test/cpp/qps/client_sync.cc +++ b/test/cpp/qps/client_sync.cc @@ -53,7 +53,7 @@ #include #include -#include "src/core/profiling/timers.h" +#include "src/core/lib/profiling/timers.h" #include "src/proto/grpc/testing/services.grpc.pb.h" #include "test/cpp/qps/client.h" #include "test/cpp/qps/histogram.h" diff --git a/test/cpp/qps/driver.cc b/test/cpp/qps/driver.cc index 6c05799d09..6cca7dec2b 100644 --- a/test/cpp/qps/driver.cc +++ b/test/cpp/qps/driver.cc @@ -45,7 +45,7 @@ #include #include -#include "src/core/support/env.h" +#include "src/core/lib/support/env.h" #include "src/proto/grpc/testing/services.grpc.pb.h" #include "test/core/util/port.h" #include "test/core/util/test_config.h" diff --git a/test/cpp/qps/qps_test_with_poll.cc b/test/cpp/qps/qps_test_with_poll.cc index 8340a6386a..647aaac4c4 100644 --- a/test/cpp/qps/qps_test_with_poll.cc +++ b/test/cpp/qps/qps_test_with_poll.cc @@ -40,7 +40,7 @@ #include "test/cpp/util/benchmark_config.h" extern "C" { -#include "src/core/iomgr/pollset_posix.h" +#include "src/core/lib/iomgr/pollset_posix.h" } namespace grpc { -- cgit v1.2.3 From dd2cfc55ab68aee249c3988d5530f0fcc6c6ec58 Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Wed, 30 Mar 2016 07:56:23 -0700 Subject: Revert "added grpclb support to sockaddr resolver" --- .../client_config/resolvers/sockaddr_resolver.c | 39 +++------------------- 1 file changed, 5 insertions(+), 34 deletions(-) (limited to 'src/core/lib/client_config') diff --git a/src/core/lib/client_config/resolvers/sockaddr_resolver.c b/src/core/lib/client_config/resolvers/sockaddr_resolver.c index 5c5133649a..c787bd57d6 100644 --- a/src/core/lib/client_config/resolvers/sockaddr_resolver.c +++ b/src/core/lib/client_config/resolvers/sockaddr_resolver.c @@ -267,46 +267,17 @@ static grpc_resolver *sockaddr_create( r->lb_policy_name = NULL; if (0 != strcmp(args->uri->query, "")) { gpr_slice query_slice; - gpr_slice_buffer query_parts; /* the &-separated elements of the query */ - gpr_slice_buffer query_param_parts; /* the =-separated subelements */ + gpr_slice_buffer query_parts; query_slice = gpr_slice_new(args->uri->query, strlen(args->uri->query), do_nothing); gpr_slice_buffer_init(&query_parts); - gpr_slice_buffer_init(&query_param_parts); - /* the query can contain "lb_policy=" and "lb_enabled=<1|0>" */ - - bool lb_enabled; - gpr_slice_split(query_slice, "&", &query_parts); - for (i = 0; i < query_parts.count; i++) { - gpr_slice_split(query_parts.slices[i], "=", &query_param_parts); - GPR_ASSERT(query_param_parts.count == 2); - if (0 == gpr_slice_str_cmp(query_param_parts.slices[0], "lb_policy")) { - r->lb_policy_name = - gpr_dump_slice(query_param_parts.slices[1], GPR_DUMP_ASCII); - } else if (0 == - gpr_slice_str_cmp(query_param_parts.slices[0], "lb_enabled")) { - if (0 != gpr_slice_str_cmp(query_param_parts.slices[1], "0")) { - /* anything other than 0 is taken to be true */ - lb_enabled = true; - } - } else { - gpr_log(GPR_ERROR, "invalid query element value: '%s'", - query_parts.slices[0]); - } - gpr_slice_buffer_reset_and_unref(&query_param_parts); - } - - 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(); + gpr_slice_split(query_slice, "=", &query_parts); + GPR_ASSERT(query_parts.count == 2); + if (0 == gpr_slice_str_cmp(query_parts.slices[0], "lb_policy")) { + r->lb_policy_name = gpr_dump_slice(query_parts.slices[1], GPR_DUMP_ASCII); } gpr_slice_buffer_destroy(&query_parts); - gpr_slice_buffer_destroy(&query_param_parts); gpr_slice_unref(query_slice); } if (r->lb_policy_name == NULL) { -- cgit v1.2.3