grpc 1.44.0.pre2-x86_64-linux → 1.46.3-x86_64-linux

data/src/ruby/ext/grpc/rb_grpc_imports.generated.c

@@ -68,7 +68,9 @@ grpc_census_call_get_context_type grpc_census_call_get_context_import;
 grpc_channel_get_target_type grpc_channel_get_target_import;
 grpc_channel_get_info_type grpc_channel_get_info_import;
 grpc_channel_reset_connect_backoff_type grpc_channel_reset_connect_backoff_import;
-grpc_insecure_channel_create_type grpc_insecure_channel_create_import;
+grpc_channel_credentials_release_type grpc_channel_credentials_release_import;
+grpc_server_credentials_release_type grpc_server_credentials_release_import;
+grpc_channel_create_type grpc_channel_create_import;
 grpc_lame_client_channel_create_type grpc_lame_client_channel_create_import;
 grpc_channel_destroy_type grpc_channel_destroy_import;
 grpc_call_cancel_type grpc_call_cancel_import;
@@ -84,7 +86,7 @@ grpc_server_register_completion_queue_type grpc_server_register_completion_queue
 grpc_server_config_fetcher_xds_create_type grpc_server_config_fetcher_xds_create_import;
 grpc_server_config_fetcher_destroy_type grpc_server_config_fetcher_destroy_import;
 grpc_server_set_config_fetcher_type grpc_server_set_config_fetcher_import;
-grpc_server_add_insecure_http2_port_type grpc_server_add_insecure_http2_port_import;
+grpc_server_add_http2_port_type grpc_server_add_http2_port_import;
 grpc_server_start_type grpc_server_start_import;
 grpc_server_shutdown_and_notify_type grpc_server_shutdown_and_notify_import;
 grpc_server_cancel_all_calls_type grpc_server_cancel_all_calls_import;
@@ -109,8 +111,8 @@ grpc_channelz_get_channel_type grpc_channelz_get_channel_import;
 grpc_channelz_get_subchannel_type grpc_channelz_get_subchannel_import;
 grpc_channelz_get_socket_type grpc_channelz_get_socket_import;
 grpc_authorization_policy_provider_arg_vtable_type grpc_authorization_policy_provider_arg_vtable_import;
-grpc_insecure_channel_create_from_fd_type grpc_insecure_channel_create_from_fd_import;
-grpc_server_add_insecure_channel_from_fd_type grpc_server_add_insecure_channel_from_fd_import;
+grpc_channel_create_from_fd_type grpc_channel_create_from_fd_import;
+grpc_server_add_channel_from_fd_type grpc_server_add_channel_from_fd_import;
 grpc_auth_property_iterator_next_type grpc_auth_property_iterator_next_import;
 grpc_auth_context_property_iterator_type grpc_auth_context_property_iterator_import;
 grpc_auth_context_peer_identity_type grpc_auth_context_peer_identity_import;
@@ -126,7 +128,6 @@ grpc_ssl_session_cache_create_lru_type grpc_ssl_session_cache_create_lru_import;
 grpc_ssl_session_cache_destroy_type grpc_ssl_session_cache_destroy_import;
 grpc_ssl_session_cache_create_channel_arg_type grpc_ssl_session_cache_create_channel_arg_import;
 grpc_call_credentials_release_type grpc_call_credentials_release_import;
-grpc_channel_credentials_release_type grpc_channel_credentials_release_import;
 grpc_google_default_credentials_create_type grpc_google_default_credentials_create_import;
 grpc_set_ssl_roots_override_callback_type grpc_set_ssl_roots_override_callback_import;
 grpc_ssl_credentials_create_type grpc_ssl_credentials_create_import;
@@ -144,8 +145,6 @@ grpc_sts_credentials_create_type grpc_sts_credentials_create_import;
 grpc_auth_metadata_context_copy_type grpc_auth_metadata_context_copy_import;
 grpc_auth_metadata_context_reset_type grpc_auth_metadata_context_reset_import;
 grpc_metadata_credentials_create_from_plugin_type grpc_metadata_credentials_create_from_plugin_import;
-grpc_secure_channel_create_type grpc_secure_channel_create_import;
-grpc_server_credentials_release_type grpc_server_credentials_release_import;
 grpc_ssl_server_certificate_config_create_type grpc_ssl_server_certificate_config_create_import;
 grpc_ssl_server_certificate_config_destroy_type grpc_ssl_server_certificate_config_destroy_import;
 grpc_ssl_server_credentials_create_type grpc_ssl_server_credentials_create_import;
@@ -154,7 +153,6 @@ grpc_ssl_server_credentials_create_options_using_config_type grpc_ssl_server_cre
 grpc_ssl_server_credentials_create_options_using_config_fetcher_type grpc_ssl_server_credentials_create_options_using_config_fetcher_import;
 grpc_ssl_server_credentials_options_destroy_type grpc_ssl_server_credentials_options_destroy_import;
 grpc_ssl_server_credentials_create_with_options_type grpc_ssl_server_credentials_create_with_options_import;
-grpc_server_add_secure_http2_port_type grpc_server_add_secure_http2_port_import;
 grpc_call_set_credentials_type grpc_call_set_credentials_import;
 grpc_server_credentials_set_auth_metadata_processor_type grpc_server_credentials_set_auth_metadata_processor_import;
 grpc_alts_credentials_client_options_create_type grpc_alts_credentials_client_options_create_import;
@@ -181,11 +179,14 @@ grpc_tls_credentials_options_set_cert_request_type_type grpc_tls_credentials_opt
 grpc_tls_credentials_options_set_crl_directory_type grpc_tls_credentials_options_set_crl_directory_import;
 grpc_tls_credentials_options_set_verify_server_cert_type grpc_tls_credentials_options_set_verify_server_cert_import;
 grpc_tls_credentials_options_set_check_call_host_type grpc_tls_credentials_options_set_check_call_host_import;
+grpc_insecure_credentials_create_type grpc_insecure_credentials_create_import;
+grpc_insecure_server_credentials_create_type grpc_insecure_server_credentials_create_import;
 grpc_xds_credentials_create_type grpc_xds_credentials_create_import;
 grpc_xds_server_credentials_create_type grpc_xds_server_credentials_create_import;
 grpc_authorization_policy_provider_static_data_create_type grpc_authorization_policy_provider_static_data_create_import;
 grpc_authorization_policy_provider_file_watcher_create_type grpc_authorization_policy_provider_file_watcher_create_import;
 grpc_authorization_policy_provider_release_type grpc_authorization_policy_provider_release_import;
+grpc_tls_credentials_options_set_tls_session_key_log_file_path_type grpc_tls_credentials_options_set_tls_session_key_log_file_path_import;
 grpc_raw_byte_buffer_create_type grpc_raw_byte_buffer_create_import;
 grpc_raw_compressed_byte_buffer_create_type grpc_raw_compressed_byte_buffer_create_import;
 grpc_byte_buffer_copy_type grpc_byte_buffer_copy_import;
@@ -212,7 +213,6 @@ grpc_slice_new_with_user_data_type grpc_slice_new_with_user_data_import;
 grpc_slice_new_with_len_type grpc_slice_new_with_len_import;
 grpc_slice_malloc_type grpc_slice_malloc_import;
 grpc_slice_malloc_large_type grpc_slice_malloc_large_import;
-grpc_slice_intern_type grpc_slice_intern_import;
 grpc_slice_from_copied_string_type grpc_slice_from_copied_string_import;
 grpc_slice_from_copied_buffer_type grpc_slice_from_copied_buffer_import;
 grpc_slice_from_static_string_type grpc_slice_from_static_string_import;
@@ -223,8 +223,6 @@ grpc_slice_split_tail_type grpc_slice_split_tail_import;
 grpc_slice_split_tail_maybe_ref_type grpc_slice_split_tail_maybe_ref_import;
 grpc_slice_split_head_type grpc_slice_split_head_import;
 grpc_empty_slice_type grpc_empty_slice_import;
-grpc_slice_default_hash_impl_type grpc_slice_default_hash_impl_import;
-grpc_slice_default_eq_impl_type grpc_slice_default_eq_impl_import;
 grpc_slice_eq_type grpc_slice_eq_import;
 grpc_slice_cmp_type grpc_slice_cmp_import;
 grpc_slice_str_cmp_type grpc_slice_str_cmp_import;
@@ -232,7 +230,6 @@ grpc_slice_buf_start_eq_type grpc_slice_buf_start_eq_import;
 grpc_slice_rchr_type grpc_slice_rchr_import;
 grpc_slice_chr_type grpc_slice_chr_import;
 grpc_slice_slice_type grpc_slice_slice_import;
-grpc_slice_hash_type grpc_slice_hash_import;
 grpc_slice_is_equivalent_type grpc_slice_is_equivalent_import;
 grpc_slice_dup_type grpc_slice_dup_import;
 grpc_slice_to_c_string_type grpc_slice_to_c_string_import;
@@ -357,7 +354,9 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_channel_get_target_import = (grpc_channel_get_target_type) GetProcAddress(library, "grpc_channel_get_target");
   grpc_channel_get_info_import = (grpc_channel_get_info_type) GetProcAddress(library, "grpc_channel_get_info");
   grpc_channel_reset_connect_backoff_import = (grpc_channel_reset_connect_backoff_type) GetProcAddress(library, "grpc_channel_reset_connect_backoff");
-  grpc_insecure_channel_create_import = (grpc_insecure_channel_create_type) GetProcAddress(library, "grpc_insecure_channel_create");
+  grpc_channel_credentials_release_import = (grpc_channel_credentials_release_type) GetProcAddress(library, "grpc_channel_credentials_release");
+  grpc_server_credentials_release_import = (grpc_server_credentials_release_type) GetProcAddress(library, "grpc_server_credentials_release");
+  grpc_channel_create_import = (grpc_channel_create_type) GetProcAddress(library, "grpc_channel_create");
   grpc_lame_client_channel_create_import = (grpc_lame_client_channel_create_type) GetProcAddress(library, "grpc_lame_client_channel_create");
   grpc_channel_destroy_import = (grpc_channel_destroy_type) GetProcAddress(library, "grpc_channel_destroy");
   grpc_call_cancel_import = (grpc_call_cancel_type) GetProcAddress(library, "grpc_call_cancel");
@@ -373,7 +372,7 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_server_config_fetcher_xds_create_import = (grpc_server_config_fetcher_xds_create_type) GetProcAddress(library, "grpc_server_config_fetcher_xds_create");
   grpc_server_config_fetcher_destroy_import = (grpc_server_config_fetcher_destroy_type) GetProcAddress(library, "grpc_server_config_fetcher_destroy");
   grpc_server_set_config_fetcher_import = (grpc_server_set_config_fetcher_type) GetProcAddress(library, "grpc_server_set_config_fetcher");
-  grpc_server_add_insecure_http2_port_import = (grpc_server_add_insecure_http2_port_type) GetProcAddress(library, "grpc_server_add_insecure_http2_port");
+  grpc_server_add_http2_port_import = (grpc_server_add_http2_port_type) GetProcAddress(library, "grpc_server_add_http2_port");
   grpc_server_start_import = (grpc_server_start_type) GetProcAddress(library, "grpc_server_start");
   grpc_server_shutdown_and_notify_import = (grpc_server_shutdown_and_notify_type) GetProcAddress(library, "grpc_server_shutdown_and_notify");
   grpc_server_cancel_all_calls_import = (grpc_server_cancel_all_calls_type) GetProcAddress(library, "grpc_server_cancel_all_calls");
@@ -398,8 +397,8 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_channelz_get_subchannel_import = (grpc_channelz_get_subchannel_type) GetProcAddress(library, "grpc_channelz_get_subchannel");
   grpc_channelz_get_socket_import = (grpc_channelz_get_socket_type) GetProcAddress(library, "grpc_channelz_get_socket");
   grpc_authorization_policy_provider_arg_vtable_import = (grpc_authorization_policy_provider_arg_vtable_type) GetProcAddress(library, "grpc_authorization_policy_provider_arg_vtable");
-  grpc_insecure_channel_create_from_fd_import = (grpc_insecure_channel_create_from_fd_type) GetProcAddress(library, "grpc_insecure_channel_create_from_fd");
-  grpc_server_add_insecure_channel_from_fd_import = (grpc_server_add_insecure_channel_from_fd_type) GetProcAddress(library, "grpc_server_add_insecure_channel_from_fd");
+  grpc_channel_create_from_fd_import = (grpc_channel_create_from_fd_type) GetProcAddress(library, "grpc_channel_create_from_fd");
+  grpc_server_add_channel_from_fd_import = (grpc_server_add_channel_from_fd_type) GetProcAddress(library, "grpc_server_add_channel_from_fd");
   grpc_auth_property_iterator_next_import = (grpc_auth_property_iterator_next_type) GetProcAddress(library, "grpc_auth_property_iterator_next");
   grpc_auth_context_property_iterator_import = (grpc_auth_context_property_iterator_type) GetProcAddress(library, "grpc_auth_context_property_iterator");
   grpc_auth_context_peer_identity_import = (grpc_auth_context_peer_identity_type) GetProcAddress(library, "grpc_auth_context_peer_identity");
@@ -415,7 +414,6 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_ssl_session_cache_destroy_import = (grpc_ssl_session_cache_destroy_type) GetProcAddress(library, "grpc_ssl_session_cache_destroy");
   grpc_ssl_session_cache_create_channel_arg_import = (grpc_ssl_session_cache_create_channel_arg_type) GetProcAddress(library, "grpc_ssl_session_cache_create_channel_arg");
   grpc_call_credentials_release_import = (grpc_call_credentials_release_type) GetProcAddress(library, "grpc_call_credentials_release");
-  grpc_channel_credentials_release_import = (grpc_channel_credentials_release_type) GetProcAddress(library, "grpc_channel_credentials_release");
   grpc_google_default_credentials_create_import = (grpc_google_default_credentials_create_type) GetProcAddress(library, "grpc_google_default_credentials_create");
   grpc_set_ssl_roots_override_callback_import = (grpc_set_ssl_roots_override_callback_type) GetProcAddress(library, "grpc_set_ssl_roots_override_callback");
   grpc_ssl_credentials_create_import = (grpc_ssl_credentials_create_type) GetProcAddress(library, "grpc_ssl_credentials_create");
@@ -433,8 +431,6 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_auth_metadata_context_copy_import = (grpc_auth_metadata_context_copy_type) GetProcAddress(library, "grpc_auth_metadata_context_copy");
   grpc_auth_metadata_context_reset_import = (grpc_auth_metadata_context_reset_type) GetProcAddress(library, "grpc_auth_metadata_context_reset");
   grpc_metadata_credentials_create_from_plugin_import = (grpc_metadata_credentials_create_from_plugin_type) GetProcAddress(library, "grpc_metadata_credentials_create_from_plugin");
-  grpc_secure_channel_create_import = (grpc_secure_channel_create_type) GetProcAddress(library, "grpc_secure_channel_create");
-  grpc_server_credentials_release_import = (grpc_server_credentials_release_type) GetProcAddress(library, "grpc_server_credentials_release");
   grpc_ssl_server_certificate_config_create_import = (grpc_ssl_server_certificate_config_create_type) GetProcAddress(library, "grpc_ssl_server_certificate_config_create");
   grpc_ssl_server_certificate_config_destroy_import = (grpc_ssl_server_certificate_config_destroy_type) GetProcAddress(library, "grpc_ssl_server_certificate_config_destroy");
   grpc_ssl_server_credentials_create_import = (grpc_ssl_server_credentials_create_type) GetProcAddress(library, "grpc_ssl_server_credentials_create");
@@ -443,7 +439,6 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_ssl_server_credentials_create_options_using_config_fetcher_import = (grpc_ssl_server_credentials_create_options_using_config_fetcher_type) GetProcAddress(library, "grpc_ssl_server_credentials_create_options_using_config_fetcher");
   grpc_ssl_server_credentials_options_destroy_import = (grpc_ssl_server_credentials_options_destroy_type) GetProcAddress(library, "grpc_ssl_server_credentials_options_destroy");
   grpc_ssl_server_credentials_create_with_options_import = (grpc_ssl_server_credentials_create_with_options_type) GetProcAddress(library, "grpc_ssl_server_credentials_create_with_options");
-  grpc_server_add_secure_http2_port_import = (grpc_server_add_secure_http2_port_type) GetProcAddress(library, "grpc_server_add_secure_http2_port");
   grpc_call_set_credentials_import = (grpc_call_set_credentials_type) GetProcAddress(library, "grpc_call_set_credentials");
   grpc_server_credentials_set_auth_metadata_processor_import = (grpc_server_credentials_set_auth_metadata_processor_type) GetProcAddress(library, "grpc_server_credentials_set_auth_metadata_processor");
   grpc_alts_credentials_client_options_create_import = (grpc_alts_credentials_client_options_create_type) GetProcAddress(library, "grpc_alts_credentials_client_options_create");
@@ -470,11 +465,14 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_tls_credentials_options_set_crl_directory_import = (grpc_tls_credentials_options_set_crl_directory_type) GetProcAddress(library, "grpc_tls_credentials_options_set_crl_directory");
   grpc_tls_credentials_options_set_verify_server_cert_import = (grpc_tls_credentials_options_set_verify_server_cert_type) GetProcAddress(library, "grpc_tls_credentials_options_set_verify_server_cert");
   grpc_tls_credentials_options_set_check_call_host_import = (grpc_tls_credentials_options_set_check_call_host_type) GetProcAddress(library, "grpc_tls_credentials_options_set_check_call_host");
+  grpc_insecure_credentials_create_import = (grpc_insecure_credentials_create_type) GetProcAddress(library, "grpc_insecure_credentials_create");
+  grpc_insecure_server_credentials_create_import = (grpc_insecure_server_credentials_create_type) GetProcAddress(library, "grpc_insecure_server_credentials_create");
   grpc_xds_credentials_create_import = (grpc_xds_credentials_create_type) GetProcAddress(library, "grpc_xds_credentials_create");
   grpc_xds_server_credentials_create_import = (grpc_xds_server_credentials_create_type) GetProcAddress(library, "grpc_xds_server_credentials_create");
   grpc_authorization_policy_provider_static_data_create_import = (grpc_authorization_policy_provider_static_data_create_type) GetProcAddress(library, "grpc_authorization_policy_provider_static_data_create");
   grpc_authorization_policy_provider_file_watcher_create_import = (grpc_authorization_policy_provider_file_watcher_create_type) GetProcAddress(library, "grpc_authorization_policy_provider_file_watcher_create");
   grpc_authorization_policy_provider_release_import = (grpc_authorization_policy_provider_release_type) GetProcAddress(library, "grpc_authorization_policy_provider_release");
+  grpc_tls_credentials_options_set_tls_session_key_log_file_path_import = (grpc_tls_credentials_options_set_tls_session_key_log_file_path_type) GetProcAddress(library, "grpc_tls_credentials_options_set_tls_session_key_log_file_path");
   grpc_raw_byte_buffer_create_import = (grpc_raw_byte_buffer_create_type) GetProcAddress(library, "grpc_raw_byte_buffer_create");
   grpc_raw_compressed_byte_buffer_create_import = (grpc_raw_compressed_byte_buffer_create_type) GetProcAddress(library, "grpc_raw_compressed_byte_buffer_create");
   grpc_byte_buffer_copy_import = (grpc_byte_buffer_copy_type) GetProcAddress(library, "grpc_byte_buffer_copy");
@@ -501,7 +499,6 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_slice_new_with_len_import = (grpc_slice_new_with_len_type) GetProcAddress(library, "grpc_slice_new_with_len");
   grpc_slice_malloc_import = (grpc_slice_malloc_type) GetProcAddress(library, "grpc_slice_malloc");
   grpc_slice_malloc_large_import = (grpc_slice_malloc_large_type) GetProcAddress(library, "grpc_slice_malloc_large");
-  grpc_slice_intern_import = (grpc_slice_intern_type) GetProcAddress(library, "grpc_slice_intern");
   grpc_slice_from_copied_string_import = (grpc_slice_from_copied_string_type) GetProcAddress(library, "grpc_slice_from_copied_string");
   grpc_slice_from_copied_buffer_import = (grpc_slice_from_copied_buffer_type) GetProcAddress(library, "grpc_slice_from_copied_buffer");
   grpc_slice_from_static_string_import = (grpc_slice_from_static_string_type) GetProcAddress(library, "grpc_slice_from_static_string");
@@ -512,8 +509,6 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_slice_split_tail_maybe_ref_import = (grpc_slice_split_tail_maybe_ref_type) GetProcAddress(library, "grpc_slice_split_tail_maybe_ref");
   grpc_slice_split_head_import = (grpc_slice_split_head_type) GetProcAddress(library, "grpc_slice_split_head");
   grpc_empty_slice_import = (grpc_empty_slice_type) GetProcAddress(library, "grpc_empty_slice");
-  grpc_slice_default_hash_impl_import = (grpc_slice_default_hash_impl_type) GetProcAddress(library, "grpc_slice_default_hash_impl");
-  grpc_slice_default_eq_impl_import = (grpc_slice_default_eq_impl_type) GetProcAddress(library, "grpc_slice_default_eq_impl");
   grpc_slice_eq_import = (grpc_slice_eq_type) GetProcAddress(library, "grpc_slice_eq");
   grpc_slice_cmp_import = (grpc_slice_cmp_type) GetProcAddress(library, "grpc_slice_cmp");
   grpc_slice_str_cmp_import = (grpc_slice_str_cmp_type) GetProcAddress(library, "grpc_slice_str_cmp");
@@ -521,7 +516,6 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_slice_rchr_import = (grpc_slice_rchr_type) GetProcAddress(library, "grpc_slice_rchr");
   grpc_slice_chr_import = (grpc_slice_chr_type) GetProcAddress(library, "grpc_slice_chr");
   grpc_slice_slice_import = (grpc_slice_slice_type) GetProcAddress(library, "grpc_slice_slice");
-  grpc_slice_hash_import = (grpc_slice_hash_type) GetProcAddress(library, "grpc_slice_hash");
   grpc_slice_is_equivalent_import = (grpc_slice_is_equivalent_type) GetProcAddress(library, "grpc_slice_is_equivalent");
   grpc_slice_dup_import = (grpc_slice_dup_type) GetProcAddress(library, "grpc_slice_dup");
   grpc_slice_to_c_string_import = (grpc_slice_to_c_string_type) GetProcAddress(library, "grpc_slice_to_c_string");

data/src/ruby/ext/grpc/rb_grpc_imports.generated.h

@@ -179,9 +179,15 @@ extern grpc_channel_get_info_type grpc_channel_get_info_import;
 typedef void(*grpc_channel_reset_connect_backoff_type)(grpc_channel* channel);
 extern grpc_channel_reset_connect_backoff_type grpc_channel_reset_connect_backoff_import;
 #define grpc_channel_reset_connect_backoff grpc_channel_reset_connect_backoff_import
-typedef grpc_channel*(*grpc_insecure_channel_create_type)(const char* target, const grpc_channel_args* args, void* reserved);
-extern grpc_insecure_channel_create_type grpc_insecure_channel_create_import;
-#define grpc_insecure_channel_create grpc_insecure_channel_create_import
+typedef void(*grpc_channel_credentials_release_type)(grpc_channel_credentials* creds);
+extern grpc_channel_credentials_release_type grpc_channel_credentials_release_import;
+#define grpc_channel_credentials_release grpc_channel_credentials_release_import
+typedef void(*grpc_server_credentials_release_type)(grpc_server_credentials* creds);
+extern grpc_server_credentials_release_type grpc_server_credentials_release_import;
+#define grpc_server_credentials_release grpc_server_credentials_release_import
+typedef grpc_channel*(*grpc_channel_create_type)(const char* target, grpc_channel_credentials* creds, const grpc_channel_args* args);
+extern grpc_channel_create_type grpc_channel_create_import;
+#define grpc_channel_create grpc_channel_create_import
 typedef grpc_channel*(*grpc_lame_client_channel_create_type)(const char* target, grpc_status_code error_code, const char* error_message);
 extern grpc_lame_client_channel_create_type grpc_lame_client_channel_create_import;
 #define grpc_lame_client_channel_create grpc_lame_client_channel_create_import
@@ -227,9 +233,9 @@ extern grpc_server_config_fetcher_destroy_type grpc_server_config_fetcher_destro
 typedef void(*grpc_server_set_config_fetcher_type)(grpc_server* server, grpc_server_config_fetcher* config_fetcher);
 extern grpc_server_set_config_fetcher_type grpc_server_set_config_fetcher_import;
 #define grpc_server_set_config_fetcher grpc_server_set_config_fetcher_import
-typedef int(*grpc_server_add_insecure_http2_port_type)(grpc_server* server, const char* addr);
-extern grpc_server_add_insecure_http2_port_type grpc_server_add_insecure_http2_port_import;
-#define grpc_server_add_insecure_http2_port grpc_server_add_insecure_http2_port_import
+typedef int(*grpc_server_add_http2_port_type)(grpc_server* server, const char* addr, grpc_server_credentials* creds);
+extern grpc_server_add_http2_port_type grpc_server_add_http2_port_import;
+#define grpc_server_add_http2_port grpc_server_add_http2_port_import
 typedef void(*grpc_server_start_type)(grpc_server* server);
 extern grpc_server_start_type grpc_server_start_import;
 #define grpc_server_start grpc_server_start_import
@@ -302,12 +308,12 @@ extern grpc_channelz_get_socket_type grpc_channelz_get_socket_import;
 typedef const grpc_arg_pointer_vtable*(*grpc_authorization_policy_provider_arg_vtable_type)(void);
 extern grpc_authorization_policy_provider_arg_vtable_type grpc_authorization_policy_provider_arg_vtable_import;
 #define grpc_authorization_policy_provider_arg_vtable grpc_authorization_policy_provider_arg_vtable_import
-typedef grpc_channel*(*grpc_insecure_channel_create_from_fd_type)(const char* target, int fd, const grpc_channel_args* args);
-extern grpc_insecure_channel_create_from_fd_type grpc_insecure_channel_create_from_fd_import;
-#define grpc_insecure_channel_create_from_fd grpc_insecure_channel_create_from_fd_import
-typedef void(*grpc_server_add_insecure_channel_from_fd_type)(grpc_server* server, void* reserved, int fd);
-extern grpc_server_add_insecure_channel_from_fd_type grpc_server_add_insecure_channel_from_fd_import;
-#define grpc_server_add_insecure_channel_from_fd grpc_server_add_insecure_channel_from_fd_import
+typedef grpc_channel*(*grpc_channel_create_from_fd_type)(const char* target, int fd, grpc_channel_credentials* creds, const grpc_channel_args* args);
+extern grpc_channel_create_from_fd_type grpc_channel_create_from_fd_import;
+#define grpc_channel_create_from_fd grpc_channel_create_from_fd_import
+typedef void(*grpc_server_add_channel_from_fd_type)(grpc_server* server, int fd, grpc_server_credentials* creds);
+extern grpc_server_add_channel_from_fd_type grpc_server_add_channel_from_fd_import;
+#define grpc_server_add_channel_from_fd grpc_server_add_channel_from_fd_import
 typedef const grpc_auth_property*(*grpc_auth_property_iterator_next_type)(grpc_auth_property_iterator* it);
 extern grpc_auth_property_iterator_next_type grpc_auth_property_iterator_next_import;
 #define grpc_auth_property_iterator_next grpc_auth_property_iterator_next_import
@@ -353,9 +359,6 @@ extern grpc_ssl_session_cache_create_channel_arg_type grpc_ssl_session_cache_cre
 typedef void(*grpc_call_credentials_release_type)(grpc_call_credentials* creds);
 extern grpc_call_credentials_release_type grpc_call_credentials_release_import;
 #define grpc_call_credentials_release grpc_call_credentials_release_import
-typedef void(*grpc_channel_credentials_release_type)(grpc_channel_credentials* creds);
-extern grpc_channel_credentials_release_type grpc_channel_credentials_release_import;
-#define grpc_channel_credentials_release grpc_channel_credentials_release_import
 typedef grpc_channel_credentials*(*grpc_google_default_credentials_create_type)(grpc_call_credentials* call_credentials);
 extern grpc_google_default_credentials_create_type grpc_google_default_credentials_create_import;
 #define grpc_google_default_credentials_create grpc_google_default_credentials_create_import
@@ -407,12 +410,6 @@ extern grpc_auth_metadata_context_reset_type grpc_auth_metadata_context_reset_im
 typedef grpc_call_credentials*(*grpc_metadata_credentials_create_from_plugin_type)(grpc_metadata_credentials_plugin plugin, grpc_security_level min_security_level, void* reserved);
 extern grpc_metadata_credentials_create_from_plugin_type grpc_metadata_credentials_create_from_plugin_import;
 #define grpc_metadata_credentials_create_from_plugin grpc_metadata_credentials_create_from_plugin_import
-typedef grpc_channel*(*grpc_secure_channel_create_type)(grpc_channel_credentials* creds, const char* target, const grpc_channel_args* args, void* reserved);
-extern grpc_secure_channel_create_type grpc_secure_channel_create_import;
-#define grpc_secure_channel_create grpc_secure_channel_create_import
-typedef void(*grpc_server_credentials_release_type)(grpc_server_credentials* creds);
-extern grpc_server_credentials_release_type grpc_server_credentials_release_import;
-#define grpc_server_credentials_release grpc_server_credentials_release_import
 typedef grpc_ssl_server_certificate_config*(*grpc_ssl_server_certificate_config_create_type)(const char* pem_root_certs, const grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs, size_t num_key_cert_pairs);
 extern grpc_ssl_server_certificate_config_create_type grpc_ssl_server_certificate_config_create_import;
 #define grpc_ssl_server_certificate_config_create grpc_ssl_server_certificate_config_create_import
@@ -437,9 +434,6 @@ extern grpc_ssl_server_credentials_options_destroy_type grpc_ssl_server_credenti
 typedef grpc_server_credentials*(*grpc_ssl_server_credentials_create_with_options_type)(grpc_ssl_server_credentials_options* options);
 extern grpc_ssl_server_credentials_create_with_options_type grpc_ssl_server_credentials_create_with_options_import;
 #define grpc_ssl_server_credentials_create_with_options grpc_ssl_server_credentials_create_with_options_import
-typedef int(*grpc_server_add_secure_http2_port_type)(grpc_server* server, const char* addr, grpc_server_credentials* creds);
-extern grpc_server_add_secure_http2_port_type grpc_server_add_secure_http2_port_import;
-#define grpc_server_add_secure_http2_port grpc_server_add_secure_http2_port_import
 typedef grpc_call_error(*grpc_call_set_credentials_type)(grpc_call* call, grpc_call_credentials* creds);
 extern grpc_call_set_credentials_type grpc_call_set_credentials_import;
 #define grpc_call_set_credentials grpc_call_set_credentials_import
@@ -518,6 +512,12 @@ extern grpc_tls_credentials_options_set_verify_server_cert_type grpc_tls_credent
 typedef void(*grpc_tls_credentials_options_set_check_call_host_type)(grpc_tls_credentials_options* options, int check_call_host);
 extern grpc_tls_credentials_options_set_check_call_host_type grpc_tls_credentials_options_set_check_call_host_import;
 #define grpc_tls_credentials_options_set_check_call_host grpc_tls_credentials_options_set_check_call_host_import
+typedef grpc_channel_credentials*(*grpc_insecure_credentials_create_type)();
+extern grpc_insecure_credentials_create_type grpc_insecure_credentials_create_import;
+#define grpc_insecure_credentials_create grpc_insecure_credentials_create_import
+typedef grpc_server_credentials*(*grpc_insecure_server_credentials_create_type)();
+extern grpc_insecure_server_credentials_create_type grpc_insecure_server_credentials_create_import;
+#define grpc_insecure_server_credentials_create grpc_insecure_server_credentials_create_import
 typedef grpc_channel_credentials*(*grpc_xds_credentials_create_type)(grpc_channel_credentials* fallback_credentials);
 extern grpc_xds_credentials_create_type grpc_xds_credentials_create_import;
 #define grpc_xds_credentials_create grpc_xds_credentials_create_import
@@ -533,6 +533,9 @@ extern grpc_authorization_policy_provider_file_watcher_create_type grpc_authoriz
 typedef void(*grpc_authorization_policy_provider_release_type)(grpc_authorization_policy_provider* provider);
 extern grpc_authorization_policy_provider_release_type grpc_authorization_policy_provider_release_import;
 #define grpc_authorization_policy_provider_release grpc_authorization_policy_provider_release_import
+typedef void(*grpc_tls_credentials_options_set_tls_session_key_log_file_path_type)(grpc_tls_credentials_options* options, const char* path);
+extern grpc_tls_credentials_options_set_tls_session_key_log_file_path_type grpc_tls_credentials_options_set_tls_session_key_log_file_path_import;
+#define grpc_tls_credentials_options_set_tls_session_key_log_file_path grpc_tls_credentials_options_set_tls_session_key_log_file_path_import
 typedef grpc_byte_buffer*(*grpc_raw_byte_buffer_create_type)(grpc_slice* slices, size_t nslices);
 extern grpc_raw_byte_buffer_create_type grpc_raw_byte_buffer_create_import;
 #define grpc_raw_byte_buffer_create grpc_raw_byte_buffer_create_import
@@ -611,9 +614,6 @@ extern grpc_slice_malloc_type grpc_slice_malloc_import;
 typedef grpc_slice(*grpc_slice_malloc_large_type)(size_t length);
 extern grpc_slice_malloc_large_type grpc_slice_malloc_large_import;
 #define grpc_slice_malloc_large grpc_slice_malloc_large_import
-typedef grpc_slice(*grpc_slice_intern_type)(grpc_slice slice);
-extern grpc_slice_intern_type grpc_slice_intern_import;
-#define grpc_slice_intern grpc_slice_intern_import
 typedef grpc_slice(*grpc_slice_from_copied_string_type)(const char* source);
 extern grpc_slice_from_copied_string_type grpc_slice_from_copied_string_import;
 #define grpc_slice_from_copied_string grpc_slice_from_copied_string_import
@@ -644,12 +644,6 @@ extern grpc_slice_split_head_type grpc_slice_split_head_import;
 typedef grpc_slice(*grpc_empty_slice_type)(void);
 extern grpc_empty_slice_type grpc_empty_slice_import;
 #define grpc_empty_slice grpc_empty_slice_import
-typedef uint32_t(*grpc_slice_default_hash_impl_type)(grpc_slice s);
-extern grpc_slice_default_hash_impl_type grpc_slice_default_hash_impl_import;
-#define grpc_slice_default_hash_impl grpc_slice_default_hash_impl_import
-typedef int(*grpc_slice_default_eq_impl_type)(grpc_slice a, grpc_slice b);
-extern grpc_slice_default_eq_impl_type grpc_slice_default_eq_impl_import;
-#define grpc_slice_default_eq_impl grpc_slice_default_eq_impl_import
 typedef int(*grpc_slice_eq_type)(grpc_slice a, grpc_slice b);
 extern grpc_slice_eq_type grpc_slice_eq_import;
 #define grpc_slice_eq grpc_slice_eq_import
@@ -671,9 +665,6 @@ extern grpc_slice_chr_type grpc_slice_chr_import;
 typedef int(*grpc_slice_slice_type)(grpc_slice haystack, grpc_slice needle);
 extern grpc_slice_slice_type grpc_slice_slice_import;
 #define grpc_slice_slice grpc_slice_slice_import
-typedef uint32_t(*grpc_slice_hash_type)(grpc_slice s);
-extern grpc_slice_hash_type grpc_slice_hash_import;
-#define grpc_slice_hash grpc_slice_hash_import
 typedef int(*grpc_slice_is_equivalent_type)(grpc_slice a, grpc_slice b);
 extern grpc_slice_is_equivalent_type grpc_slice_is_equivalent_import;
 #define grpc_slice_is_equivalent grpc_slice_is_equivalent_import

data/src/ruby/ext/grpc/rb_server.c

@@ -320,8 +320,11 @@ static VALUE grpc_rb_server_add_http2_port(VALUE self, VALUE port,
       rb_raise(rb_eTypeError, "bad creds symbol, want :this_port_is_insecure");
       return Qnil;
     }
-    recvd_port =
-        grpc_server_add_insecure_http2_port(s->wrapped, StringValueCStr(port));
+    grpc_server_credentials* insecure_creds =
+        grpc_insecure_server_credentials_create();
+    recvd_port = grpc_server_add_http2_port(s->wrapped, StringValueCStr(port),
+                                            insecure_creds);
+    grpc_server_credentials_release(insecure_creds);
     if (recvd_port == 0) {
       rb_raise(rb_eRuntimeError,
                "could not add port %s to server, not sure why",
@@ -340,8 +343,8 @@ static VALUE grpc_rb_server_add_http2_port(VALUE self, VALUE port,
                "failed to create server because credentials parameter has an "
                "invalid type, want ServerCredentials or XdsServerCredentials");
     }
-    recvd_port = grpc_server_add_secure_http2_port(
-        s->wrapped, StringValueCStr(port), creds);
+    recvd_port =
+        grpc_server_add_http2_port(s->wrapped, StringValueCStr(port), creds);
     if (recvd_port == 0) {
       rb_raise(rb_eRuntimeError,
                "could not add secure port %s to server, not sure why",

data/src/ruby/lib/grpc/generic/active_call.rb

@@ -164,7 +164,13 @@ module GRPC
     end
 
     def receive_and_check_status
-      batch_result = @call.run_batch(RECV_STATUS_ON_CLIENT => nil)
+      ops = { RECV_STATUS_ON_CLIENT => nil }
+      ops[RECV_INITIAL_METADATA] = nil unless @metadata_received
+      batch_result = @call.run_batch(ops)
+      unless @metadata_received
+        @call.metadata = batch_result.metadata
+        @metadata_received = true
+      end
       set_input_stream_done
       attach_status_results_and_complete_call(batch_result)
     end

data/src/ruby/lib/grpc/grpc.rb

@@ -16,7 +16,7 @@ begin
   ruby_version_dirname = /(\d+\.\d+)/.match(RUBY_VERSION).to_s
   distrib_lib_dir = File.expand_path(ruby_version_dirname,
                                      File.dirname(__FILE__))
-  if File.directory?(distrib_lib_dir)
+  if !Dir.glob("#{distrib_lib_dir}/grpc_c*").empty?
     require "#{distrib_lib_dir}/grpc_c"
   else
     require 'grpc/grpc_c'

data/src/ruby/lib/grpc/version.rb

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.44.0.pre2'
+  VERSION = '1.46.3'
 end

data/src/ruby/pb/generate_proto_ruby.sh

@@ -40,6 +40,7 @@ $PROTOC -I . \
     --plugin=$PLUGIN
 
 $PROTOC -I . \
+    -I third_party/protobuf/src \
     src/proto/grpc/testing/{messages,payloads,stats,benchmark_service,report_qps_scenario_service,worker_service,control}.proto \
     --grpc_out=src/ruby/qps \
     --ruby_out=src/ruby/qps \

data/third_party/abseil-cpp/absl/algorithm/algorithm.h

@@ -0,0 +1,159 @@
+// Copyright 2017 The Abseil 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// File: algorithm.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains Google extensions to the standard <algorithm> C++
+// header.
+
+#ifndef ABSL_ALGORITHM_ALGORITHM_H_
+#define ABSL_ALGORITHM_ALGORITHM_H_
+
+#include <algorithm>
+#include <iterator>
+#include <type_traits>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace algorithm_internal {
+
+// Performs comparisons with operator==, similar to C++14's `std::equal_to<>`.
+struct EqualTo {
+  template <typename T, typename U>
+  bool operator()(const T& a, const U& b) const {
+    return a == b;
+  }
+};
+
+template <typename InputIter1, typename InputIter2, typename Pred>
+bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+               InputIter2 last2, Pred pred, std::input_iterator_tag,
+               std::input_iterator_tag) {
+  while (true) {
+    if (first1 == last1) return first2 == last2;
+    if (first2 == last2) return false;
+    if (!pred(*first1, *first2)) return false;
+    ++first1;
+    ++first2;
+  }
+}
+
+template <typename InputIter1, typename InputIter2, typename Pred>
+bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+               InputIter2 last2, Pred&& pred, std::random_access_iterator_tag,
+               std::random_access_iterator_tag) {
+  return (last1 - first1 == last2 - first2) &&
+         std::equal(first1, last1, first2, std::forward<Pred>(pred));
+}
+
+// When we are using our own internal predicate that just applies operator==, we
+// forward to the non-predicate form of std::equal. This enables an optimization
+// in libstdc++ that can result in std::memcmp being used for integer types.
+template <typename InputIter1, typename InputIter2>
+bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+               InputIter2 last2, algorithm_internal::EqualTo /* unused */,
+               std::random_access_iterator_tag,
+               std::random_access_iterator_tag) {
+  return (last1 - first1 == last2 - first2) &&
+         std::equal(first1, last1, first2);
+}
+
+template <typename It>
+It RotateImpl(It first, It middle, It last, std::true_type) {
+  return std::rotate(first, middle, last);
+}
+
+template <typename It>
+It RotateImpl(It first, It middle, It last, std::false_type) {
+  std::rotate(first, middle, last);
+  return std::next(first, std::distance(middle, last));
+}
+
+}  // namespace algorithm_internal
+
+// equal()
+//
+// Compares the equality of two ranges specified by pairs of iterators, using
+// the given predicate, returning true iff for each corresponding iterator i1
+// and i2 in the first and second range respectively, pred(*i1, *i2) == true
+//
+// This comparison takes at most min(`last1` - `first1`, `last2` - `first2`)
+// invocations of the predicate. Additionally, if InputIter1 and InputIter2 are
+// both random-access iterators, and `last1` - `first1` != `last2` - `first2`,
+// then the predicate is never invoked and the function returns false.
+//
+// This is a C++11-compatible implementation of C++14 `std::equal`.  See
+// https://en.cppreference.com/w/cpp/algorithm/equal for more information.
+template <typename InputIter1, typename InputIter2, typename Pred>
+bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+           InputIter2 last2, Pred&& pred) {
+  return algorithm_internal::EqualImpl(
+      first1, last1, first2, last2, std::forward<Pred>(pred),
+      typename std::iterator_traits<InputIter1>::iterator_category{},
+      typename std::iterator_traits<InputIter2>::iterator_category{});
+}
+
+// Overload of equal() that performs comparison of two ranges specified by pairs
+// of iterators using operator==.
+template <typename InputIter1, typename InputIter2>
+bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+           InputIter2 last2) {
+  return absl::equal(first1, last1, first2, last2,
+                     algorithm_internal::EqualTo{});
+}
+
+// linear_search()
+//
+// Performs a linear search for `value` using the iterator `first` up to
+// but not including `last`, returning true if [`first`, `last`) contains an
+// element equal to `value`.
+//
+// A linear search is of O(n) complexity which is guaranteed to make at most
+// n = (`last` - `first`) comparisons. A linear search over short containers
+// may be faster than a binary search, even when the container is sorted.
+template <typename InputIterator, typename EqualityComparable>
+bool linear_search(InputIterator first, InputIterator last,
+                   const EqualityComparable& value) {
+  return std::find(first, last, value) != last;
+}
+
+// rotate()
+//
+// Performs a left rotation on a range of elements (`first`, `last`) such that
+// `middle` is now the first element. `rotate()` returns an iterator pointing to
+// the first element before rotation. This function is exactly the same as
+// `std::rotate`, but fixes a bug in gcc
+// <= 4.9 where `std::rotate` returns `void` instead of an iterator.
+//
+// The complexity of this algorithm is the same as that of `std::rotate`, but if
+// `ForwardIterator` is not a random-access iterator, then `absl::rotate`
+// performs an additional pass over the range to construct the return value.
+template <typename ForwardIterator>
+ForwardIterator rotate(ForwardIterator first, ForwardIterator middle,
+                       ForwardIterator last) {
+  return algorithm_internal::RotateImpl(
+      first, middle, last,
+      std::is_same<decltype(std::rotate(first, middle, last)),
+                   ForwardIterator>());
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_ALGORITHM_ALGORITHM_H_