grpc 1.43.1 → 1.48.0

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -22,19 +22,21 @@
 
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/surface/builtins.h"
+#include "src/core/lib/transport/http_connect_handshaker.h"
+#include "src/core/lib/transport/tcp_connect_handshaker.h"
+
+extern void grpc_register_extra_plugins(void);
 
 void grpc_chttp2_plugin_init(void);
 void grpc_chttp2_plugin_shutdown(void);
 void grpc_client_channel_init(void);
 void grpc_client_channel_shutdown(void);
-void grpc_inproc_plugin_init(void);
-void grpc_inproc_plugin_shutdown(void);
-void grpc_resolver_fake_init(void);
-void grpc_resolver_fake_shutdown(void);
 void grpc_lb_policy_grpclb_init(void);
 void grpc_lb_policy_grpclb_shutdown(void);
 void grpc_lb_policy_priority_init(void);
 void grpc_lb_policy_priority_shutdown(void);
+void grpc_lb_policy_outlier_detection_init(void);
+void grpc_lb_policy_outlier_detection_shutdown(void);
 void grpc_lb_policy_weighted_target_init(void);
 void grpc_lb_policy_weighted_target_shutdown(void);
 void grpc_lb_policy_pick_first_init(void);
@@ -43,70 +45,25 @@ void grpc_lb_policy_round_robin_init(void);
 void grpc_lb_policy_round_robin_shutdown(void);
 void grpc_resolver_dns_ares_init(void);
 void grpc_resolver_dns_ares_shutdown(void);
-void grpc_resolver_dns_native_init(void);
-void grpc_resolver_dns_native_shutdown(void);
-void grpc_resolver_sockaddr_init(void);
-void grpc_resolver_sockaddr_shutdown(void);
-void grpc_message_size_filter_init(void);
-void grpc_message_size_filter_shutdown(void);
 namespace grpc_core {
-void FaultInjectionFilterInit(void);
-void FaultInjectionFilterShutdown(void);
 void GrpcLbPolicyRingHashInit(void);
 void GrpcLbPolicyRingHashShutdown(void);
 #ifndef GRPC_NO_RLS
 void RlsLbPluginInit();
 void RlsLbPluginShutdown();
 #endif  // !GRPC_NO_RLS
-void ServiceConfigParserInit(void);
-void ServiceConfigParserShutdown(void);
-}  // namespace grpc_core
-
-#ifndef GRPC_NO_XDS
-namespace grpc_core {
-void XdsClientGlobalInit();
-void XdsClientGlobalShutdown();
-}  // namespace grpc_core
-void grpc_certificate_provider_registry_init(void);
-void grpc_certificate_provider_registry_shutdown(void);
-namespace grpc_core {
-void FileWatcherCertificateProviderInit();
-void FileWatcherCertificateProviderShutdown();
-}  // namespace grpc_core
-void grpc_lb_policy_cds_init(void);
-void grpc_lb_policy_cds_shutdown(void);
-void grpc_lb_policy_xds_cluster_impl_init(void);
-void grpc_lb_policy_xds_cluster_impl_shutdown(void);
-void grpc_lb_policy_xds_cluster_resolver_init(void);
-void grpc_lb_policy_xds_cluster_resolver_shutdown(void);
-void grpc_lb_policy_xds_cluster_manager_init(void);
-void grpc_lb_policy_xds_cluster_manager_shutdown(void);
-void grpc_resolver_xds_init(void);
-void grpc_resolver_xds_shutdown(void);
-namespace grpc_core {
-void GoogleCloud2ProdResolverInit();
-void GoogleCloud2ProdResolverShutdown();
 }  // namespace grpc_core
-#endif
-
-#ifdef GPR_SUPPORT_BINDER_TRANSPORT
-void grpc_resolver_binder_init(void);
-void grpc_resolver_binder_shutdown(void);
-#endif
 
 void grpc_register_built_in_plugins(void) {
-  grpc_register_plugin(grpc_chttp2_plugin_init, grpc_chttp2_plugin_shutdown);
-  grpc_register_plugin(grpc_core::ServiceConfigParserInit,
-                       grpc_core::ServiceConfigParserShutdown);
   grpc_register_plugin(grpc_client_channel_init, grpc_client_channel_shutdown);
-  grpc_register_plugin(grpc_inproc_plugin_init, grpc_inproc_plugin_shutdown);
-  grpc_register_plugin(grpc_resolver_fake_init, grpc_resolver_fake_shutdown);
   grpc_register_plugin(grpc_lb_policy_grpclb_init,
                        grpc_lb_policy_grpclb_shutdown);
 #ifndef GRPC_NO_RLS
   grpc_register_plugin(grpc_core::RlsLbPluginInit,
                        grpc_core::RlsLbPluginShutdown);
 #endif  // !GRPC_NO_RLS
+  grpc_register_plugin(grpc_lb_policy_outlier_detection_init,
+                       grpc_lb_policy_outlier_detection_shutdown);
   grpc_register_plugin(grpc_lb_policy_priority_init,
                        grpc_lb_policy_priority_shutdown);
   grpc_register_plugin(grpc_lb_policy_weighted_target_init,
@@ -119,37 +76,7 @@ void grpc_register_built_in_plugins(void) {
                        grpc_core::GrpcLbPolicyRingHashShutdown);
   grpc_register_plugin(grpc_resolver_dns_ares_init,
                        grpc_resolver_dns_ares_shutdown);
-  grpc_register_plugin(grpc_resolver_dns_native_init,
-                       grpc_resolver_dns_native_shutdown);
-  grpc_register_plugin(grpc_resolver_sockaddr_init,
-                       grpc_resolver_sockaddr_shutdown);
-  grpc_register_plugin(grpc_message_size_filter_init,
-                       grpc_message_size_filter_shutdown);
-  grpc_register_plugin(grpc_core::FaultInjectionFilterInit,
-                       grpc_core::FaultInjectionFilterShutdown);
-#ifndef GRPC_NO_XDS
-  grpc_register_plugin(grpc_core::XdsClientGlobalInit,
-                       grpc_core::XdsClientGlobalShutdown);
-  grpc_register_plugin(grpc_certificate_provider_registry_init,
-                       grpc_certificate_provider_registry_shutdown);
-  grpc_register_plugin(grpc_core::FileWatcherCertificateProviderInit,
-                       grpc_core::FileWatcherCertificateProviderShutdown);
-  grpc_register_plugin(grpc_lb_policy_cds_init, grpc_lb_policy_cds_shutdown);
-  grpc_register_plugin(grpc_lb_policy_xds_cluster_impl_init,
-                       grpc_lb_policy_xds_cluster_impl_shutdown);
-  grpc_register_plugin(grpc_lb_policy_xds_cluster_resolver_init,
-                       grpc_lb_policy_xds_cluster_resolver_shutdown);
-  grpc_register_plugin(grpc_lb_policy_xds_cluster_manager_init,
-                       grpc_lb_policy_xds_cluster_manager_shutdown);
-  grpc_register_plugin(grpc_resolver_xds_init, grpc_resolver_xds_shutdown);
-  grpc_register_plugin(grpc_core::GoogleCloud2ProdResolverInit,
-                       grpc_core::GoogleCloud2ProdResolverShutdown);
-#endif
-
-#ifdef GPR_SUPPORT_BINDER_TRANSPORT
-  grpc_register_plugin(grpc_resolver_binder_init,
-                       grpc_resolver_binder_shutdown);
-#endif
+  grpc_register_extra_plugins();
 }
 
 namespace grpc_core {
@@ -159,40 +86,54 @@ extern void BuildClientChannelConfiguration(
 extern void SecurityRegisterHandshakerFactories(
     CoreConfiguration::Builder* builder);
 extern void RegisterClientAuthorityFilter(CoreConfiguration::Builder* builder);
-extern void RegisterClientIdleFilter(CoreConfiguration::Builder* builder);
+extern void RegisterChannelIdleFilters(CoreConfiguration::Builder* builder);
 extern void RegisterDeadlineFilter(CoreConfiguration::Builder* builder);
 extern void RegisterGrpcLbLoadReportingFilter(
     CoreConfiguration::Builder* builder);
 extern void RegisterHttpFilters(CoreConfiguration::Builder* builder);
-extern void RegisterMaxAgeFilter(CoreConfiguration::Builder* builder);
 extern void RegisterMessageSizeFilter(CoreConfiguration::Builder* builder);
 extern void RegisterSecurityFilters(CoreConfiguration::Builder* builder);
 extern void RegisterServiceConfigChannelArgFilter(
     CoreConfiguration::Builder* builder);
+extern void RegisterExtraFilters(CoreConfiguration::Builder* builder);
 extern void RegisterResourceQuota(CoreConfiguration::Builder* builder);
-#ifndef GRPC_NO_XDS
-extern void RegisterXdsChannelStackModifier(
-    CoreConfiguration::Builder* builder);
+extern void FaultInjectionFilterRegister(CoreConfiguration::Builder* builder);
+extern void RegisterNativeDnsResolver(CoreConfiguration::Builder* builder);
+extern void RegisterAresDnsResolver(CoreConfiguration::Builder* builder);
+extern void RegisterSockaddrResolver(CoreConfiguration::Builder* builder);
+extern void RegisterFakeResolver(CoreConfiguration::Builder* builder);
+#ifdef GPR_SUPPORT_BINDER_TRANSPORT
+extern void RegisterBinderResolver(CoreConfiguration::Builder* builder);
 #endif
 
 void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
+  // The order of the handshaker registration is crucial here.
+  // We want TCP connect handshaker to be registered last so that it is added to
+  // the start of the handshaker list.
+  RegisterHttpConnectHandshaker(builder);
+  RegisterTCPConnectHandshaker(builder);
   BuildClientChannelConfiguration(builder);
   SecurityRegisterHandshakerFactories(builder);
   RegisterClientAuthorityFilter(builder);
-  RegisterClientIdleFilter(builder);
+  RegisterChannelIdleFilters(builder);
   RegisterGrpcLbLoadReportingFilter(builder);
   RegisterHttpFilters(builder);
-  RegisterMaxAgeFilter(builder);
   RegisterDeadlineFilter(builder);
   RegisterMessageSizeFilter(builder);
   RegisterServiceConfigChannelArgFilter(builder);
   RegisterResourceQuota(builder);
-#ifndef GRPC_NO_XDS
-  RegisterXdsChannelStackModifier(builder);
+  FaultInjectionFilterRegister(builder);
+  RegisterAresDnsResolver(builder);
+  RegisterNativeDnsResolver(builder);
+  RegisterSockaddrResolver(builder);
+  RegisterFakeResolver(builder);
+#ifdef GPR_SUPPORT_BINDER_TRANSPORT
+  RegisterBinderResolver(builder);
 #endif
   // Run last so it gets a consistent location.
   // TODO(ctiller): Is this actually necessary?
   RegisterSecurityFilters(builder);
+  RegisterExtraFilters(builder);
   RegisterBuiltins(builder);
 }
 

data/src/core/plugin_registry/grpc_plugin_registry_extra.cc

@@ -0,0 +1,85 @@
+//
+// Copyright 2021 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 <grpc/grpc.h>
+
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/surface/builtins.h"
+
+#ifndef GRPC_NO_XDS
+namespace grpc_core {
+void XdsClientGlobalInit();
+void XdsClientGlobalShutdown();
+}  // namespace grpc_core
+void grpc_certificate_provider_registry_init(void);
+void grpc_certificate_provider_registry_shutdown(void);
+namespace grpc_core {
+void FileWatcherCertificateProviderInit();
+void FileWatcherCertificateProviderShutdown();
+}  // namespace grpc_core
+void grpc_lb_policy_cds_init(void);
+void grpc_lb_policy_cds_shutdown(void);
+void grpc_lb_policy_xds_cluster_impl_init(void);
+void grpc_lb_policy_xds_cluster_impl_shutdown(void);
+void grpc_lb_policy_xds_cluster_resolver_init(void);
+void grpc_lb_policy_xds_cluster_resolver_shutdown(void);
+void grpc_lb_policy_xds_cluster_manager_init(void);
+void grpc_lb_policy_xds_cluster_manager_shutdown(void);
+#endif
+
+void grpc_register_extra_plugins() {
+#ifndef GRPC_NO_XDS
+  grpc_register_plugin(grpc_core::XdsClientGlobalInit,
+                       grpc_core::XdsClientGlobalShutdown);
+  grpc_register_plugin(grpc_certificate_provider_registry_init,
+                       grpc_certificate_provider_registry_shutdown);
+  grpc_register_plugin(grpc_core::FileWatcherCertificateProviderInit,
+                       grpc_core::FileWatcherCertificateProviderShutdown);
+  grpc_register_plugin(grpc_lb_policy_cds_init, grpc_lb_policy_cds_shutdown);
+  grpc_register_plugin(grpc_lb_policy_xds_cluster_impl_init,
+                       grpc_lb_policy_xds_cluster_impl_shutdown);
+  grpc_register_plugin(grpc_lb_policy_xds_cluster_resolver_init,
+                       grpc_lb_policy_xds_cluster_resolver_shutdown);
+  grpc_register_plugin(grpc_lb_policy_xds_cluster_manager_init,
+                       grpc_lb_policy_xds_cluster_manager_shutdown);
+#endif
+}
+
+namespace grpc_core {
+#ifndef GRPC_NO_XDS
+extern void RbacFilterRegister(CoreConfiguration::Builder* builder);
+extern void RegisterXdsChannelStackModifier(
+    CoreConfiguration::Builder* builder);
+extern void RegisterChannelDefaultCreds(CoreConfiguration::Builder* builder);
+extern void RegisterXdsResolver(CoreConfiguration::Builder* builder);
+extern void RegisterCloud2ProdResolver(CoreConfiguration::Builder* builder);
+#endif
+void RegisterExtraFilters(CoreConfiguration::Builder* builder) {
+  // Use builder to avoid unused-parameter warning.
+  (void)builder;
+#ifndef GRPC_NO_XDS
+  // rbac_filter is being guarded with GRPC_NO_XDS to avoid a dependency on the
+  // re2 library by default
+  RbacFilterRegister(builder);
+  RegisterXdsChannelStackModifier(builder);
+  RegisterChannelDefaultCreds(builder);
+  RegisterXdsResolver(builder);
+  RegisterCloud2ProdResolver(builder);
+#endif
+}
+}  // namespace grpc_core

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -209,13 +209,13 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
   }
   /* TSI handshake has been shutdown. */
   if (alts_tsi_handshaker_has_shutdown(handshaker)) {
-    gpr_log(GPR_ERROR, "TSI handshake shutdown");
+    gpr_log(GPR_INFO, "TSI handshake shutdown");
     handle_response_done(client, TSI_HANDSHAKE_SHUTDOWN, nullptr, 0, nullptr);
     return;
   }
   /* Failed grpc call check. */
   if (!is_ok || status != GRPC_STATUS_OK) {
-    gpr_log(GPR_ERROR, "grpc call made to handshaker service failed");
+    gpr_log(GPR_INFO, "grpc call made to handshaker service failed");
     handle_response_done(client, TSI_INTERNAL_ERROR, nullptr, 0, nullptr);
     return;
   }
@@ -243,7 +243,7 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
     handle_response_done(client, TSI_DATA_CORRUPTED, nullptr, 0, nullptr);
     return;
   }
-  upb_strview out_frames = grpc_gcp_HandshakerResp_out_frames(resp);
+  upb_StringView out_frames = grpc_gcp_HandshakerResp_out_frames(resp);
   unsigned char* bytes_to_send = nullptr;
   size_t bytes_to_send_size = 0;
   if (out_frames.size > 0) {
@@ -272,7 +272,7 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
   grpc_status_code code = static_cast<grpc_status_code>(
       grpc_gcp_HandshakerStatus_code(resp_status));
   if (code != GRPC_STATUS_OK) {
-    upb_strview details = grpc_gcp_HandshakerStatus_details(resp_status);
+    upb_StringView details = grpc_gcp_HandshakerStatus_details(resp_status);
     if (details.size > 0) {
       char* error_details = static_cast<char*>(gpr_zalloc(details.size + 1));
       memcpy(error_details, details.data, details.size);
@@ -462,7 +462,7 @@ static void on_status_received(void* arg, grpc_error_handle error) {
 /* Serializes a grpc_gcp_HandshakerReq message into a buffer and returns newly
  * grpc_byte_buffer holding it. */
 static grpc_byte_buffer* get_serialized_handshaker_req(
-    grpc_gcp_HandshakerReq* req, upb_arena* arena) {
+    grpc_gcp_HandshakerReq* req, upb_Arena* arena) {
   size_t buf_length;
   char* buf = grpc_gcp_HandshakerReq_serialize(req, arena, &buf_length);
   if (buf == nullptr) {
@@ -487,19 +487,21 @@ static grpc_byte_buffer* get_serialized_start_client(
   grpc_gcp_StartClientHandshakeReq_set_handshake_security_protocol(
       start_client, grpc_gcp_ALTS);
   grpc_gcp_StartClientHandshakeReq_add_application_protocols(
-      start_client, upb_strview_makez(ALTS_APPLICATION_PROTOCOL), arena.ptr());
+      start_client, upb_StringView_FromString(ALTS_APPLICATION_PROTOCOL),
+      arena.ptr());
   grpc_gcp_StartClientHandshakeReq_add_record_protocols(
-      start_client, upb_strview_makez(ALTS_RECORD_PROTOCOL), arena.ptr());
+      start_client, upb_StringView_FromString(ALTS_RECORD_PROTOCOL),
+      arena.ptr());
   grpc_gcp_RpcProtocolVersions* client_version =
       grpc_gcp_StartClientHandshakeReq_mutable_rpc_versions(start_client,
                                                             arena.ptr());
   grpc_gcp_RpcProtocolVersions_assign_from_struct(
       client_version, arena.ptr(), &client->options->rpc_versions);
   grpc_gcp_StartClientHandshakeReq_set_target_name(
-      start_client,
-      upb_strview_make(reinterpret_cast<const char*>(
-                           GRPC_SLICE_START_PTR(client->target_name)),
-                       GRPC_SLICE_LENGTH(client->target_name)));
+      start_client, upb_StringView_FromDataAndSize(
+                        reinterpret_cast<const char*>(
+                            GRPC_SLICE_START_PTR(client->target_name)),
+                        GRPC_SLICE_LENGTH(client->target_name)));
   target_service_account* ptr =
       (reinterpret_cast<grpc_alts_credentials_client_options*>(client->options))
           ->target_account_list_head;
@@ -508,7 +510,7 @@ static grpc_byte_buffer* get_serialized_start_client(
         grpc_gcp_StartClientHandshakeReq_add_target_identities(start_client,
                                                                arena.ptr());
     grpc_gcp_Identity_set_service_account(target_identity,
-                                          upb_strview_makez(ptr->data));
+                                          upb_StringView_FromString(ptr->data));
     ptr = ptr->next;
   }
   grpc_gcp_StartClientHandshakeReq_set_max_frame_size(
@@ -551,17 +553,19 @@ static grpc_byte_buffer* get_serialized_start_server(
   grpc_gcp_StartServerHandshakeReq* start_server =
       grpc_gcp_HandshakerReq_mutable_server_start(req, arena.ptr());
   grpc_gcp_StartServerHandshakeReq_add_application_protocols(
-      start_server, upb_strview_makez(ALTS_APPLICATION_PROTOCOL), arena.ptr());
+      start_server, upb_StringView_FromString(ALTS_APPLICATION_PROTOCOL),
+      arena.ptr());
   grpc_gcp_ServerHandshakeParameters* value =
       grpc_gcp_ServerHandshakeParameters_new(arena.ptr());
   grpc_gcp_ServerHandshakeParameters_add_record_protocols(
-      value, upb_strview_makez(ALTS_RECORD_PROTOCOL), arena.ptr());
+      value, upb_StringView_FromString(ALTS_RECORD_PROTOCOL), arena.ptr());
   grpc_gcp_StartServerHandshakeReq_handshake_parameters_set(
       start_server, grpc_gcp_ALTS, value, arena.ptr());
   grpc_gcp_StartServerHandshakeReq_set_in_bytes(
-      start_server, upb_strview_make(reinterpret_cast<const char*>(
-                                         GRPC_SLICE_START_PTR(*bytes_received)),
-                                     GRPC_SLICE_LENGTH(*bytes_received)));
+      start_server,
+      upb_StringView_FromDataAndSize(
+          reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(*bytes_received)),
+          GRPC_SLICE_LENGTH(*bytes_received)));
   grpc_gcp_RpcProtocolVersions* server_version =
       grpc_gcp_StartServerHandshakeReq_mutable_rpc_versions(start_server,
                                                             arena.ptr());
@@ -602,9 +606,10 @@ static grpc_byte_buffer* get_serialized_next(grpc_slice* bytes_received) {
   grpc_gcp_NextHandshakeMessageReq* next =
       grpc_gcp_HandshakerReq_mutable_next(req, arena.ptr());
   grpc_gcp_NextHandshakeMessageReq_set_in_bytes(
-      next, upb_strview_make(reinterpret_cast<const char*> GRPC_SLICE_START_PTR(
-                                 *bytes_received),
-                             GRPC_SLICE_LENGTH(*bytes_received)));
+      next,
+      upb_StringView_FromDataAndSize(
+          reinterpret_cast<const char*> GRPC_SLICE_START_PTR(*bytes_received),
+          GRPC_SLICE_LENGTH(*bytes_received)));
   return get_serialized_handshaker_req(req, arena.ptr());
 }
 
@@ -716,12 +721,12 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
           : grpc_channel_create_pollset_set_call(
                 channel, nullptr, GRPC_PROPAGATE_DEFAULTS, interested_parties,
                 grpc_slice_from_static_string(ALTS_SERVICE_METHOD), &slice,
-                GRPC_MILLIS_INF_FUTURE, nullptr);
+                grpc_core::Timestamp::InfFuture(), nullptr);
+  grpc_slice_unref_internal(slice);
   GRPC_CLOSURE_INIT(&client->on_handshaker_service_resp_recv, grpc_cb, client,
                     grpc_schedule_on_exec_ctx);
   GRPC_CLOSURE_INIT(&client->on_status_received, on_status_received, client,
                     grpc_schedule_on_exec_ctx);
-  grpc_slice_unref_internal(slice);
   return &client->base;
 }
 

data/src/core/tsi/alts/handshaker/alts_shared_resource.cc

@@ -22,6 +22,7 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/tsi/alts/handshaker/alts_handshaker_client.h"
 
 static alts_shared_resource_dedicated g_alts_resource_dedicated;
@@ -55,8 +56,15 @@ void grpc_alts_shared_resource_dedicated_start(
     const char* handshaker_service_url) {
   gpr_mu_lock(&g_alts_resource_dedicated.mu);
   if (g_alts_resource_dedicated.cq == nullptr) {
+    grpc_channel_credentials* creds = grpc_insecure_credentials_create();
+    // Disable retries so that we quickly get a signal when the
+    // handshake server is not reachable.
+    grpc_arg disable_retries_arg = grpc_channel_arg_integer_create(
+        const_cast<char*>(GRPC_ARG_ENABLE_RETRIES), 0);
+    grpc_channel_args args = {1, &disable_retries_arg};
     g_alts_resource_dedicated.channel =
-        grpc_insecure_channel_create(handshaker_service_url, nullptr, nullptr);
+        grpc_channel_create(handshaker_service_url, creds, &args);
+    grpc_channel_credentials_release(creds);
     g_alts_resource_dedicated.cq =
         grpc_completion_queue_create_for_next(nullptr);
     g_alts_resource_dedicated.thread =

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.cc

@@ -26,6 +26,7 @@
 
 #include "upb/upb.hpp"
 
+#include <grpc/grpc_security.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -276,13 +277,13 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     gpr_log(GPR_ERROR, "Invalid identity");
     return TSI_FAILED_PRECONDITION;
   }
-  upb_strview peer_service_account =
+  upb_StringView peer_service_account =
       grpc_gcp_Identity_service_account(identity);
   if (peer_service_account.size == 0) {
     gpr_log(GPR_ERROR, "Invalid peer service account");
     return TSI_FAILED_PRECONDITION;
   }
-  upb_strview key_data = grpc_gcp_HandshakerResult_key_data(hresult);
+  upb_StringView key_data = grpc_gcp_HandshakerResult_key_data(hresult);
   if (key_data.size < kAltsAes128GcmRekeyKeyLength) {
     gpr_log(GPR_ERROR, "Bad key length");
     return TSI_FAILED_PRECONDITION;
@@ -293,13 +294,13 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     gpr_log(GPR_ERROR, "Peer does not set RPC protocol versions.");
     return TSI_FAILED_PRECONDITION;
   }
-  upb_strview application_protocol =
+  upb_StringView application_protocol =
       grpc_gcp_HandshakerResult_application_protocol(hresult);
   if (application_protocol.size == 0) {
     gpr_log(GPR_ERROR, "Invalid application protocol");
     return TSI_FAILED_PRECONDITION;
   }
-  upb_strview record_protocol =
+  upb_StringView record_protocol =
       grpc_gcp_HandshakerResult_record_protocol(hresult);
   if (record_protocol.size == 0) {
     gpr_log(GPR_ERROR, "Invalid record protocol");
@@ -311,7 +312,7 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     gpr_log(GPR_ERROR, "Invalid local identity");
     return TSI_FAILED_PRECONDITION;
   }
-  upb_strview local_service_account =
+  upb_StringView local_service_account =
       grpc_gcp_Identity_service_account(local_identity);
   // We don't check if local service account is empty here
   // because local identity could be empty in certain situations.
@@ -350,14 +351,14 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     return TSI_FAILED_PRECONDITION;
   }
   if (grpc_gcp_Identity_has_attributes(identity)) {
-    size_t iter = UPB_MAP_BEGIN;
+    size_t iter = kUpb_Map_Begin;
     grpc_gcp_Identity_AttributesEntry* peer_attributes_entry =
         grpc_gcp_Identity_attributes_nextmutable(peer_identity, &iter);
     while (peer_attributes_entry != nullptr) {
-      upb_strview key = grpc_gcp_Identity_AttributesEntry_key(
+      upb_StringView key = grpc_gcp_Identity_AttributesEntry_key(
           const_cast<grpc_gcp_Identity_AttributesEntry*>(
               peer_attributes_entry));
-      upb_strview val = grpc_gcp_Identity_AttributesEntry_value(
+      upb_StringView val = grpc_gcp_Identity_AttributesEntry_value(
           const_cast<grpc_gcp_Identity_AttributesEntry*>(
               peer_attributes_entry));
       grpc_gcp_AltsContext_peer_attributes_set(context, key, val,
@@ -390,8 +391,8 @@ static void on_handshaker_service_resp_recv(void* arg,
     return;
   }
   bool success = true;
-  if (error != GRPC_ERROR_NONE) {
-    gpr_log(GPR_ERROR,
+  if (!GRPC_ERROR_IS_NONE(error)) {
+    gpr_log(GPR_INFO,
             "ALTS handshaker on_handshaker_service_resp_recv error: %s",
             grpc_error_std_string(error).c_str());
     success = false;
@@ -446,7 +447,7 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
       GPR_ASSERT(handshaker->client == nullptr);
       handshaker->client = client;
       if (handshaker->shutdown) {
-        gpr_log(GPR_ERROR, "TSI handshake shutdown");
+        gpr_log(GPR_INFO, "TSI handshake shutdown");
         return TSI_HANDSHAKE_SHUTDOWN;
       }
     }
@@ -497,8 +498,15 @@ static void alts_tsi_handshaker_create_channel(
       static_cast<alts_tsi_handshaker_continue_handshaker_next_args*>(arg);
   alts_tsi_handshaker* handshaker = next_args->handshaker;
   GPR_ASSERT(handshaker->channel == nullptr);
-  handshaker->channel = grpc_insecure_channel_create(
-      next_args->handshaker->handshaker_service_url, nullptr, nullptr);
+  grpc_channel_credentials* creds = grpc_insecure_credentials_create();
+  // Disable retries so that we quickly get a signal when the
+  // handshake server is not reachable.
+  grpc_arg disable_retries_arg = grpc_channel_arg_integer_create(
+      const_cast<char*>(GRPC_ARG_ENABLE_RETRIES), 0);
+  grpc_channel_args args = {1, &disable_retries_arg};
+  handshaker->channel = grpc_channel_create(
+      next_args->handshaker->handshaker_service_url, creds, &args);
+  grpc_channel_credentials_release(creds);
   tsi_result continue_next_result =
       alts_tsi_handshaker_continue_handshaker_next(
           handshaker, next_args->received_bytes.get(),
@@ -524,7 +532,7 @@ static tsi_result handshaker_next(
   {
     grpc_core::MutexLock lock(&handshaker->mu);
     if (handshaker->shutdown) {
-      gpr_log(GPR_ERROR, "TSI handshake shutdown");
+      gpr_log(GPR_INFO, "TSI handshake shutdown");
       return TSI_HANDSHAKE_SHUTDOWN;
     }
   }

data/src/core/tsi/alts/handshaker/alts_tsi_utils.cc

@@ -42,14 +42,14 @@ tsi_result alts_tsi_utils_convert_to_tsi_result(grpc_status_code code) {
 }
 
 grpc_gcp_HandshakerResp* alts_tsi_utils_deserialize_response(
-    grpc_byte_buffer* resp_buffer, upb_arena* arena) {
+    grpc_byte_buffer* resp_buffer, upb_Arena* arena) {
   GPR_ASSERT(resp_buffer != nullptr);
   GPR_ASSERT(arena != nullptr);
   grpc_byte_buffer_reader bbr;
   grpc_byte_buffer_reader_init(&bbr, resp_buffer);
   grpc_slice slice = grpc_byte_buffer_reader_readall(&bbr);
   size_t buf_size = GPR_SLICE_LENGTH(slice);
-  void* buf = upb_arena_malloc(arena, buf_size);
+  void* buf = upb_Arena_Malloc(arena, buf_size);
   memcpy(buf, reinterpret_cast<const char*>(GPR_SLICE_START_PTR(slice)),
          buf_size);
   grpc_gcp_HandshakerResp* resp = grpc_gcp_HandshakerResp_parse(

data/src/core/tsi/alts/handshaker/alts_tsi_utils.h

@@ -48,6 +48,6 @@ tsi_result alts_tsi_utils_convert_to_tsi_result(grpc_status_code code);
  * failure.
  */
 grpc_gcp_HandshakerResp* alts_tsi_utils_deserialize_response(
-    grpc_byte_buffer* resp_buffer, upb_arena* arena);
+    grpc_byte_buffer* resp_buffer, upb_Arena* arena);
 
 #endif /* GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_TSI_UTILS_H */

data/src/core/tsi/alts/handshaker/transport_security_common_api.cc

@@ -68,7 +68,7 @@ bool grpc_gcp_rpc_protocol_versions_encode(
 }
 
 bool grpc_gcp_rpc_protocol_versions_encode(
-    const grpc_gcp_RpcProtocolVersions* versions, upb_arena* arena,
+    const grpc_gcp_RpcProtocolVersions* versions, upb_Arena* arena,
     grpc_slice* slice) {
   if (versions == nullptr || arena == nullptr || slice == nullptr) {
     gpr_log(GPR_ERROR,
@@ -135,7 +135,7 @@ void grpc_gcp_rpc_protocol_versions_assign_from_upb(
 }
 
 void grpc_gcp_RpcProtocolVersions_assign_from_struct(
-    grpc_gcp_RpcProtocolVersions* versions, upb_arena* arena,
+    grpc_gcp_RpcProtocolVersions* versions, upb_Arena* arena,
     const grpc_gcp_rpc_protocol_versions* value) {
   grpc_gcp_RpcProtocolVersions_Version* max_version_msg =
       grpc_gcp_RpcProtocolVersions_mutable_max_rpc_version(versions, arena);

data/src/core/tsi/alts/handshaker/transport_security_common_api.h

@@ -91,7 +91,7 @@ bool grpc_gcp_rpc_protocol_versions_encode(
  * The method returns true on success and false otherwise.
  */
 bool grpc_gcp_rpc_protocol_versions_encode(
-    const grpc_gcp_RpcProtocolVersions* versions, upb_arena* arena,
+    const grpc_gcp_RpcProtocolVersions* versions, upb_Arena* arena,
     grpc_slice* slice);
 
 /**
@@ -119,7 +119,7 @@ void grpc_gcp_rpc_protocol_versions_assign_from_upb(
  * RpcProtocolVersions.
  */
 void grpc_gcp_RpcProtocolVersions_assign_from_struct(
-    grpc_gcp_RpcProtocolVersions* versions, upb_arena* arena,
+    grpc_gcp_RpcProtocolVersions* versions, upb_Arena* arena,
     const grpc_gcp_rpc_protocol_versions* value);
 
 /**

data/src/core/tsi/alts/zero_copy_frame_protector/alts_zero_copy_grpc_protector.cc

@@ -174,7 +174,7 @@ static tsi_result alts_zero_copy_grpc_protector_protect(
 
 static tsi_result alts_zero_copy_grpc_protector_unprotect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
-    grpc_slice_buffer* unprotected_slices) {
+    grpc_slice_buffer* unprotected_slices, int* min_progress_size) {
   if (self == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
     gpr_log(GPR_ERROR,
@@ -215,6 +215,14 @@ static tsi_result alts_zero_copy_grpc_protector_unprotect(
       return status;
     }
   }
+  if (min_progress_size != nullptr) {
+    if (protector->parsed_frame_size > kZeroCopyFrameLengthFieldSize) {
+      *min_progress_size =
+          protector->parsed_frame_size - protector->protected_sb.length;
+    } else {
+      *min_progress_size = 1;
+    }
+  }
   return TSI_OK;
 }