grpc 1.26.0 → 1.27.0.pre1

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.cc

@@ -0,0 +1,89 @@
+//
+// Copyright 2019 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gpr/useful.h"
+
+// Channel arg key for the list of balancer addresses.
+#define GRPC_ARG_GRPCLB_BALANCER_ADDRESSES "grpc.grpclb_balancer_addresses"
+// Channel arg key for a string indicating an address's balancer name.
+#define GRPC_ARG_ADDRESS_BALANCER_NAME "grpc.address_balancer_name"
+
+namespace grpc_core {
+
+namespace {
+
+void* BalancerAddressesArgCopy(void* p) {
+  ServerAddressList* address_list = static_cast<ServerAddressList*>(p);
+  return new ServerAddressList(*address_list);
+}
+
+void BalancerAddressesArgDestroy(void* p) {
+  ServerAddressList* address_list = static_cast<ServerAddressList*>(p);
+  delete address_list;
+}
+
+int BalancerAddressesArgCmp(void* p, void* q) {
+  ServerAddressList* address_list1 = static_cast<ServerAddressList*>(p);
+  ServerAddressList* address_list2 = static_cast<ServerAddressList*>(q);
+  if (address_list1 == nullptr || address_list2 == nullptr) {
+    return GPR_ICMP(address_list1, address_list2);
+  }
+  if (address_list1->size() > address_list2->size()) return 1;
+  if (address_list1->size() < address_list2->size()) return -1;
+  for (size_t i = 0; i < address_list1->size(); ++i) {
+    int retval = (*address_list1)[i].Cmp((*address_list2)[i]);
+    if (retval != 0) return retval;
+  }
+  return 0;
+}
+
+const grpc_arg_pointer_vtable kBalancerAddressesArgVtable = {
+    BalancerAddressesArgCopy, BalancerAddressesArgDestroy,
+    BalancerAddressesArgCmp};
+
+}  // namespace
+
+grpc_arg CreateGrpclbBalancerAddressesArg(
+    const ServerAddressList* address_list) {
+  return grpc_channel_arg_pointer_create(
+      const_cast<char*>(GRPC_ARG_GRPCLB_BALANCER_ADDRESSES),
+      const_cast<ServerAddressList*>(address_list),
+      &kBalancerAddressesArgVtable);
+}
+
+const ServerAddressList* FindGrpclbBalancerAddressesInChannelArgs(
+    const grpc_channel_args& args) {
+  return grpc_channel_args_find_pointer<const ServerAddressList>(
+      &args, const_cast<char*>(GRPC_ARG_GRPCLB_BALANCER_ADDRESSES));
+}
+
+grpc_arg CreateGrpclbBalancerNameArg(const char* balancer_name) {
+  return grpc_channel_arg_string_create(
+      const_cast<char*>(GRPC_ARG_ADDRESS_BALANCER_NAME),
+      const_cast<char*>(balancer_name));
+}
+
+const char* FindGrpclbBalancerNameInChannelArgs(const grpc_channel_args& args) {
+  return grpc_channel_args_find_string(
+      &args, const_cast<char*>(GRPC_ARG_ADDRESS_BALANCER_NAME));
+}
+
+}  // namespace grpc_core

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.h

@@ -0,0 +1,40 @@
+//
+// Copyright 2019 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_GRPCLB_BALANCER_ADDRESSES_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_GRPCLB_BALANCER_ADDRESSES_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/grpc_types.h>
+
+#include "src/core/ext/filters/client_channel/server_address.h"
+
+namespace grpc_core {
+
+grpc_arg CreateGrpclbBalancerAddressesArg(
+    const ServerAddressList* address_list);
+const ServerAddressList* FindGrpclbBalancerAddressesInChannelArgs(
+    const grpc_channel_args& args);
+
+grpc_arg CreateGrpclbBalancerNameArg(const char* balancer_name);
+const char* FindGrpclbBalancerNameInChannelArgs(const grpc_channel_args& args);
+
+}  // namespace grpc_core
+
+#endif /*                                                                         \
+GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_GRPCLB_BALANCER_ADDRESSES_H \
+        */

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_channel_secure.cc

@@ -27,6 +27,7 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
+#include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.h"
 #include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
@@ -55,8 +56,8 @@ RefCountedPtr<TargetAuthorityTable> CreateTargetAuthorityTable(
         grpc_sockaddr_to_string(&addr_str, &addresses[i].address(), true) > 0);
     target_authority_entries[i].key = grpc_slice_from_copied_string(addr_str);
     gpr_free(addr_str);
-    char* balancer_name = grpc_channel_arg_get_string(grpc_channel_args_find(
-        addresses[i].args(), GRPC_ARG_ADDRESS_BALANCER_NAME));
+    const char* balancer_name =
+        FindGrpclbBalancerNameInChannelArgs(*addresses[i].args());
     target_authority_entries[i].value.reset(gpr_strdup(balancer_name));
   }
   RefCountedPtr<TargetAuthorityTable> target_authority_table =

data/src/core/ext/filters/client_channel/lb_policy/grpclb/load_balancer_api.cc

@@ -28,16 +28,38 @@
 
 namespace grpc_core {
 
-grpc_grpclb_request* grpc_grpclb_request_create(const char* lb_service_name,
-                                                upb_arena* arena) {
-  grpc_grpclb_request* req = grpc_lb_v1_LoadBalanceRequest_new(arena);
+bool GrpcLbServer::operator==(const GrpcLbServer& other) const {
+  if (ip_size != other.ip_size) return false;
+  int r = memcmp(ip_addr, other.ip_addr, ip_size);
+  if (r != 0) return false;
+  if (port != other.port) return false;
+  r = strncmp(load_balance_token, other.load_balance_token,
+              sizeof(load_balance_token));
+  if (r != 0) return false;
+  return drop == other.drop;
+}
+
+namespace {
+
+grpc_slice grpc_grpclb_request_encode(
+    const grpc_lb_v1_LoadBalanceRequest* request, upb_arena* arena) {
+  size_t buf_length;
+  char* buf =
+      grpc_lb_v1_LoadBalanceRequest_serialize(request, arena, &buf_length);
+  return grpc_slice_from_copied_buffer(buf, buf_length);
+}
+
+}  // namespace
+
+grpc_slice GrpcLbRequestCreate(const char* lb_service_name, upb_arena* arena) {
+  grpc_lb_v1_LoadBalanceRequest* req = grpc_lb_v1_LoadBalanceRequest_new(arena);
   grpc_lb_v1_InitialLoadBalanceRequest* initial_request =
       grpc_lb_v1_LoadBalanceRequest_mutable_initial_request(req, arena);
   size_t name_len =
       GPR_MIN(strlen(lb_service_name), GRPC_GRPCLB_SERVICE_NAME_MAX_LENGTH);
   grpc_lb_v1_InitialLoadBalanceRequest_set_name(
       initial_request, upb_strview_make(lb_service_name, name_len));
-  return req;
+  return grpc_grpclb_request_encode(req, arena);
 }
 
 namespace {
@@ -50,23 +72,18 @@ void google_protobuf_Timestamp_assign(google_protobuf_Timestamp* timestamp,
 
 }  // namespace
 
-grpc_grpclb_request* grpc_grpclb_load_report_request_create(
-    GrpcLbClientStats* client_stats, upb_arena* arena) {
-  grpc_grpclb_request* req = grpc_lb_v1_LoadBalanceRequest_new(arena);
+grpc_slice GrpcLbLoadReportRequestCreate(
+    int64_t num_calls_started, int64_t num_calls_finished,
+    int64_t num_calls_finished_with_client_failed_to_send,
+    int64_t num_calls_finished_known_received,
+    const GrpcLbClientStats::DroppedCallCounts* drop_token_counts,
+    upb_arena* arena) {
+  grpc_lb_v1_LoadBalanceRequest* req = grpc_lb_v1_LoadBalanceRequest_new(arena);
   grpc_lb_v1_ClientStats* req_stats =
       grpc_lb_v1_LoadBalanceRequest_mutable_client_stats(req, arena);
   google_protobuf_Timestamp_assign(
       grpc_lb_v1_ClientStats_mutable_timestamp(req_stats, arena),
       gpr_now(GPR_CLOCK_REALTIME));
-
-  int64_t num_calls_started;
-  int64_t num_calls_finished;
-  int64_t num_calls_finished_with_client_failed_to_send;
-  int64_t num_calls_finished_known_received;
-  std::unique_ptr<GrpcLbClientStats::DroppedCallCounts> drop_token_counts;
-  client_stats->Get(&num_calls_started, &num_calls_finished,
-                    &num_calls_finished_with_client_failed_to_send,
-                    &num_calls_finished_known_received, &drop_token_counts);
   grpc_lb_v1_ClientStats_set_num_calls_started(req_stats, num_calls_started);
   grpc_lb_v1_ClientStats_set_num_calls_finished(req_stats, num_calls_finished);
   grpc_lb_v1_ClientStats_set_num_calls_finished_with_client_failed_to_send(
@@ -75,152 +92,102 @@ grpc_grpclb_request* grpc_grpclb_load_report_request_create(
       req_stats, num_calls_finished_known_received);
   if (drop_token_counts != nullptr) {
     for (size_t i = 0; i < drop_token_counts->size(); ++i) {
-      GrpcLbClientStats::DropTokenCount& cur = (*drop_token_counts)[i];
+      const GrpcLbClientStats::DropTokenCount& cur = (*drop_token_counts)[i];
       grpc_lb_v1_ClientStatsPerToken* cur_msg =
           grpc_lb_v1_ClientStats_add_calls_finished_with_drop(req_stats, arena);
-
       const size_t token_len = strlen(cur.token.get());
       char* token = reinterpret_cast<char*>(upb_arena_malloc(arena, token_len));
       memcpy(token, cur.token.get(), token_len);
-
       grpc_lb_v1_ClientStatsPerToken_set_load_balance_token(
           cur_msg, upb_strview_make(token, token_len));
       grpc_lb_v1_ClientStatsPerToken_set_num_calls(cur_msg, cur.count);
     }
   }
-  return req;
+  return grpc_grpclb_request_encode(req, arena);
 }
 
-grpc_slice grpc_grpclb_request_encode(const grpc_grpclb_request* request,
-                                      upb_arena* arena) {
-  size_t buf_length;
-  char* buf =
-      grpc_lb_v1_LoadBalanceRequest_serialize(request, arena, &buf_length);
-  return grpc_slice_from_copied_buffer(buf, buf_length);
-}
-
-const grpc_grpclb_initial_response* grpc_grpclb_initial_response_parse(
-    const grpc_slice& encoded_grpc_grpclb_response, upb_arena* arena) {
-  grpc_lb_v1_LoadBalanceResponse* response =
-      grpc_lb_v1_LoadBalanceResponse_parse(
-          reinterpret_cast<const char*>(
-              GRPC_SLICE_START_PTR(encoded_grpc_grpclb_response)),
-          GRPC_SLICE_LENGTH(encoded_grpc_grpclb_response), arena);
-  if (response == nullptr) {
-    gpr_log(GPR_ERROR, "grpc_lb_v1_LoadBalanceResponse parse error");
-    return nullptr;
-  }
-  return grpc_lb_v1_LoadBalanceResponse_initial_response(response);
-}
+namespace {
 
-grpc_grpclb_serverlist* grpc_grpclb_response_parse_serverlist(
-    const grpc_slice& encoded_grpc_grpclb_response) {
-  upb::Arena arena;
-  grpc_lb_v1_LoadBalanceResponse* response =
-      grpc_lb_v1_LoadBalanceResponse_parse(
-          reinterpret_cast<const char*>(
-              GRPC_SLICE_START_PTR(encoded_grpc_grpclb_response)),
-          GRPC_SLICE_LENGTH(encoded_grpc_grpclb_response), arena.ptr());
-  if (response == nullptr) {
-    gpr_log(GPR_ERROR, "grpc_lb_v1_LoadBalanceResponse parse error");
-    return nullptr;
-  }
-  grpc_grpclb_serverlist* server_list = static_cast<grpc_grpclb_serverlist*>(
-      gpr_zalloc(sizeof(grpc_grpclb_serverlist)));
-  // First pass: count number of servers.
+bool ParseServerList(const grpc_lb_v1_LoadBalanceResponse& response,
+                     std::vector<GrpcLbServer>* server_list) {
+  // Determine the number of servers.
   const grpc_lb_v1_ServerList* server_list_msg =
-      grpc_lb_v1_LoadBalanceResponse_server_list(response);
+      grpc_lb_v1_LoadBalanceResponse_server_list(&response);
+  if (server_list_msg == nullptr) return false;
   size_t server_count = 0;
-  const grpc_lb_v1_Server* const* servers = nullptr;
-  if (server_list_msg != nullptr) {
-    servers = grpc_lb_v1_ServerList_servers(server_list_msg, &server_count);
-  }
-  // Second pass: populate servers.
+  const grpc_lb_v1_Server* const* servers =
+      grpc_lb_v1_ServerList_servers(server_list_msg, &server_count);
+  // Populate servers.
   if (server_count > 0) {
-    server_list->servers = static_cast<grpc_grpclb_server**>(
-        gpr_zalloc(sizeof(grpc_grpclb_server*) * server_count));
-    server_list->num_servers = server_count;
+    server_list->reserve(server_count);
     for (size_t i = 0; i < server_count; ++i) {
-      grpc_grpclb_server* cur = server_list->servers[i] =
-          static_cast<grpc_grpclb_server*>(
-              gpr_zalloc(sizeof(grpc_grpclb_server)));
+      GrpcLbServer& cur = *server_list->emplace(server_list->end());
       upb_strview address = grpc_lb_v1_Server_ip_address(servers[i]);
       if (address.size == 0) {
         ;  // Nothing to do because cur->ip_address is an empty string.
       } else if (address.size <= GRPC_GRPCLB_SERVER_IP_ADDRESS_MAX_SIZE) {
-        cur->ip_address.size = static_cast<int32_t>(address.size);
-        memcpy(cur->ip_address.data, address.data, address.size);
+        cur.ip_size = static_cast<int32_t>(address.size);
+        memcpy(cur.ip_addr, address.data, address.size);
       }
-      cur->port = grpc_lb_v1_Server_port(servers[i]);
+      cur.port = grpc_lb_v1_Server_port(servers[i]);
       upb_strview token = grpc_lb_v1_Server_load_balance_token(servers[i]);
       if (token.size == 0) {
         ;  // Nothing to do because cur->load_balance_token is an empty string.
       } else if (token.size <= GRPC_GRPCLB_SERVER_LOAD_BALANCE_TOKEN_MAX_SIZE) {
-        memcpy(cur->load_balance_token, token.data, token.size);
+        memcpy(cur.load_balance_token, token.data, token.size);
       } else {
         gpr_log(GPR_ERROR,
                 "grpc_lb_v1_LoadBalanceResponse has too long token. len=%zu",
                 token.size);
       }
-      cur->drop = grpc_lb_v1_Server_drop(servers[i]);
+      cur.drop = grpc_lb_v1_Server_drop(servers[i]);
     }
   }
-  return server_list;
+  return true;
 }
 
-void grpc_grpclb_destroy_serverlist(grpc_grpclb_serverlist* serverlist) {
-  if (serverlist == nullptr) {
-    return;
-  }
-  for (size_t i = 0; i < serverlist->num_servers; i++) {
-    gpr_free(serverlist->servers[i]);
-  }
-  gpr_free(serverlist->servers);
-  gpr_free(serverlist);
+grpc_millis grpc_grpclb_duration_to_millis(
+    const google_protobuf_Duration* duration_pb) {
+  return static_cast<grpc_millis>(
+      (google_protobuf_Duration_seconds(duration_pb) * GPR_MS_PER_SEC) +
+      (google_protobuf_Duration_nanos(duration_pb) / GPR_NS_PER_MS));
 }
 
-grpc_grpclb_serverlist* grpc_grpclb_serverlist_copy(
-    const grpc_grpclb_serverlist* server_list) {
-  grpc_grpclb_serverlist* copy = static_cast<grpc_grpclb_serverlist*>(
-      gpr_zalloc(sizeof(grpc_grpclb_serverlist)));
-  copy->num_servers = server_list->num_servers;
-  copy->servers = static_cast<grpc_grpclb_server**>(
-      gpr_malloc(sizeof(grpc_grpclb_server*) * server_list->num_servers));
-  for (size_t i = 0; i < server_list->num_servers; i++) {
-    copy->servers[i] = static_cast<grpc_grpclb_server*>(
-        gpr_malloc(sizeof(grpc_grpclb_server)));
-    memcpy(copy->servers[i], server_list->servers[i],
-           sizeof(grpc_grpclb_server));
-  }
-  return copy;
-}
+}  // namespace
 
-bool grpc_grpclb_serverlist_equals(const grpc_grpclb_serverlist* lhs,
-                                   const grpc_grpclb_serverlist* rhs) {
-  if (lhs == nullptr || rhs == nullptr) {
-    return false;
-  }
-  if (lhs->num_servers != rhs->num_servers) {
-    return false;
+bool GrpcLbResponseParse(const grpc_slice& encoded_grpc_grpclb_response,
+                         upb_arena* arena, GrpcLbResponse* result) {
+  grpc_lb_v1_LoadBalanceResponse* response =
+      grpc_lb_v1_LoadBalanceResponse_parse(
+          reinterpret_cast<const char*>(
+              GRPC_SLICE_START_PTR(encoded_grpc_grpclb_response)),
+          GRPC_SLICE_LENGTH(encoded_grpc_grpclb_response), arena);
+  // Handle serverlist responses.
+  if (ParseServerList(*response, &result->serverlist)) {
+    result->type = result->SERVERLIST;
+    return true;
   }
-  for (size_t i = 0; i < lhs->num_servers; i++) {
-    if (!grpc_grpclb_server_equals(lhs->servers[i], rhs->servers[i])) {
-      return false;
+  // Handle initial responses.
+  auto* initial_response =
+      grpc_lb_v1_LoadBalanceResponse_initial_response(response);
+  if (initial_response != nullptr) {
+    result->type = result->INITIAL;
+    const google_protobuf_Duration* client_stats_report_interval =
+        grpc_lb_v1_InitialLoadBalanceResponse_client_stats_report_interval(
+            initial_response);
+    if (client_stats_report_interval != nullptr) {
+      result->client_stats_report_interval =
+          grpc_grpclb_duration_to_millis(client_stats_report_interval);
     }
+    return true;
   }
-  return true;
-}
-
-bool grpc_grpclb_server_equals(const grpc_grpclb_server* lhs,
-                               const grpc_grpclb_server* rhs) {
-  return memcmp(lhs, rhs, sizeof(grpc_grpclb_server)) == 0;
-}
-
-grpc_millis grpc_grpclb_duration_to_millis(
-    const grpc_grpclb_duration* duration_pb) {
-  return static_cast<grpc_millis>(
-      google_protobuf_Duration_seconds(duration_pb) * GPR_MS_PER_SEC +
-      google_protobuf_Duration_nanos(duration_pb) / GPR_NS_PER_MS);
+  // Handle fallback.
+  if (grpc_lb_v1_LoadBalanceResponse_has_fallback_response(response)) {
+    result->type = result->FALLBACK;
+    return true;
+  }
+  // Unknown response type.
+  return false;
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/lb_policy/grpclb/load_balancer_api.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <vector>
+
 #include <grpc/slice_buffer.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_client_stats.h"
@@ -33,69 +35,38 @@
 
 namespace grpc_core {
 
-typedef grpc_lb_v1_LoadBalanceRequest grpc_grpclb_request;
-typedef grpc_lb_v1_LoadBalanceResponse grpc_grpclb_response;
-typedef grpc_lb_v1_InitialLoadBalanceResponse grpc_grpclb_initial_response;
-typedef google_protobuf_Duration grpc_grpclb_duration;
-typedef google_protobuf_Timestamp grpc_grpclb_timestamp;
-
-typedef struct {
-  int32_t size;
-  char data[GRPC_GRPCLB_SERVER_IP_ADDRESS_MAX_SIZE];
-} grpc_grpclb_server_ip_address;
-
 // Contains server information. When the drop field is not true, use the other
 // fields.
-typedef struct {
-  grpc_grpclb_server_ip_address ip_address;
+struct GrpcLbServer {
+  int32_t ip_size;
+  char ip_addr[GRPC_GRPCLB_SERVER_IP_ADDRESS_MAX_SIZE];
   int32_t port;
   char load_balance_token[GRPC_GRPCLB_SERVER_LOAD_BALANCE_TOKEN_MAX_SIZE];
   bool drop;
-} grpc_grpclb_server;
-
-typedef struct {
-  grpc_grpclb_server** servers;
-  size_t num_servers;
-} grpc_grpclb_serverlist;
-
-/**
- * Create a request for a gRPC LB service under \a lb_service_name.
- * \a lb_service_name should be alive when returned request is being used.
- */
-grpc_grpclb_request* grpc_grpclb_request_create(const char* lb_service_name,
-                                                upb_arena* arena);
-grpc_grpclb_request* grpc_grpclb_load_report_request_create(
-    grpc_core::GrpcLbClientStats* client_stats, upb_arena* arena);
-
-/** Protocol Buffers v3-encode \a request */
-grpc_slice grpc_grpclb_request_encode(const grpc_grpclb_request* request,
-                                      upb_arena* arena);
-
-/** Parse (ie, decode) the bytes in \a encoded_grpc_grpclb_response as a \a
- * grpc_grpclb_initial_response */
-const grpc_grpclb_initial_response* grpc_grpclb_initial_response_parse(
-    const grpc_slice& encoded_grpc_grpclb_response, upb_arena* arena);
-
-/** Parse the list of servers from an encoded \a grpc_grpclb_response */
-grpc_grpclb_serverlist* grpc_grpclb_response_parse_serverlist(
-    const grpc_slice& encoded_grpc_grpclb_response);
-
-/** Return a copy of \a sl. The caller is responsible for calling \a
- * grpc_grpclb_destroy_serverlist on the returned copy. */
-grpc_grpclb_serverlist* grpc_grpclb_serverlist_copy(
-    const grpc_grpclb_serverlist* sl);
-
-bool grpc_grpclb_serverlist_equals(const grpc_grpclb_serverlist* lhs,
-                                   const grpc_grpclb_serverlist* rhs);
-
-bool grpc_grpclb_server_equals(const grpc_grpclb_server* lhs,
-                               const grpc_grpclb_server* rhs);
-
-/** Destroy \a serverlist */
-void grpc_grpclb_destroy_serverlist(grpc_grpclb_serverlist* serverlist);
 
-grpc_millis grpc_grpclb_duration_to_millis(
-    const grpc_grpclb_duration* duration_pb);
+  bool operator==(const GrpcLbServer& other) const;
+};
+
+struct GrpcLbResponse {
+  enum { INITIAL, SERVERLIST, FALLBACK } type;
+  grpc_millis client_stats_report_interval = 0;
+  std::vector<GrpcLbServer> serverlist;
+};
+
+// Creates a serialized grpclb request.
+grpc_slice GrpcLbRequestCreate(const char* lb_service_name, upb_arena* arena);
+
+// Creates a serialized grpclb load report request.
+grpc_slice GrpcLbLoadReportRequestCreate(
+    int64_t num_calls_started, int64_t num_calls_finished,
+    int64_t num_calls_finished_with_client_failed_to_send,
+    int64_t num_calls_finished_known_received,
+    const GrpcLbClientStats::DroppedCallCounts* drop_token_counts,
+    upb_arena* arena);
+
+// Deserialize a grpclb response.
+bool GrpcLbResponseParse(const grpc_slice& serialized_response,
+                         upb_arena* arena, GrpcLbResponse* response);
 
 }  // namespace grpc_core