grpc 1.34.0 → 1.42.0

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

@@ -47,7 +47,7 @@ extern grpc_compression_algorithm_is_message_type grpc_compression_algorithm_is_
 typedef int(*grpc_compression_algorithm_is_stream_type)(grpc_compression_algorithm algorithm);
 extern grpc_compression_algorithm_is_stream_type grpc_compression_algorithm_is_stream_import;
 #define grpc_compression_algorithm_is_stream grpc_compression_algorithm_is_stream_import
-typedef int(*grpc_compression_algorithm_parse_type)(grpc_slice value, grpc_compression_algorithm* algorithm);
+typedef int(*grpc_compression_algorithm_parse_type)(grpc_slice name, grpc_compression_algorithm* algorithm);
 extern grpc_compression_algorithm_parse_type grpc_compression_algorithm_parse_import;
 #define grpc_compression_algorithm_parse grpc_compression_algorithm_parse_import
 typedef int(*grpc_compression_algorithm_name_type)(grpc_compression_algorithm algorithm, const char** name);
@@ -110,7 +110,7 @@ extern grpc_completion_queue_create_for_next_type grpc_completion_queue_create_f
 typedef grpc_completion_queue*(*grpc_completion_queue_create_for_pluck_type)(void* reserved);
 extern grpc_completion_queue_create_for_pluck_type grpc_completion_queue_create_for_pluck_import;
 #define grpc_completion_queue_create_for_pluck grpc_completion_queue_create_for_pluck_import
-typedef grpc_completion_queue*(*grpc_completion_queue_create_for_callback_type)(grpc_experimental_completion_queue_functor* shutdown_callback, void* reserved);
+typedef grpc_completion_queue*(*grpc_completion_queue_create_for_callback_type)(grpc_completion_queue_functor* shutdown_callback, void* reserved);
 extern grpc_completion_queue_create_for_callback_type grpc_completion_queue_create_for_callback_import;
 #define grpc_completion_queue_create_for_callback grpc_completion_queue_create_for_callback_import
 typedef grpc_completion_queue*(*grpc_completion_queue_create_type)(const grpc_completion_queue_factory* factory, const grpc_completion_queue_attributes* attributes, void* reserved);
@@ -194,6 +194,9 @@ extern grpc_call_cancel_type grpc_call_cancel_import;
 typedef grpc_call_error(*grpc_call_cancel_with_status_type)(grpc_call* call, grpc_status_code status, const char* description, void* reserved);
 extern grpc_call_cancel_with_status_type grpc_call_cancel_with_status_import;
 #define grpc_call_cancel_with_status grpc_call_cancel_with_status_import
+typedef int(*grpc_call_failed_before_recv_message_type)(const grpc_call* c);
+extern grpc_call_failed_before_recv_message_type grpc_call_failed_before_recv_message_import;
+#define grpc_call_failed_before_recv_message grpc_call_failed_before_recv_message_import
 typedef void(*grpc_call_ref_type)(grpc_call* call);
 extern grpc_call_ref_type grpc_call_ref_import;
 #define grpc_call_ref grpc_call_ref_import
@@ -215,6 +218,15 @@ extern grpc_server_create_type grpc_server_create_import;
 typedef void(*grpc_server_register_completion_queue_type)(grpc_server* server, grpc_completion_queue* cq, void* reserved);
 extern grpc_server_register_completion_queue_type grpc_server_register_completion_queue_import;
 #define grpc_server_register_completion_queue grpc_server_register_completion_queue_import
+typedef grpc_server_config_fetcher*(*grpc_server_config_fetcher_xds_create_type)(grpc_server_xds_status_notifier notifier, const grpc_channel_args* args);
+extern grpc_server_config_fetcher_xds_create_type grpc_server_config_fetcher_xds_create_import;
+#define grpc_server_config_fetcher_xds_create grpc_server_config_fetcher_xds_create_import
+typedef void(*grpc_server_config_fetcher_destroy_type)(grpc_server_config_fetcher* config_fetcher);
+extern grpc_server_config_fetcher_destroy_type grpc_server_config_fetcher_destroy_import;
+#define grpc_server_config_fetcher_destroy grpc_server_config_fetcher_destroy_import
+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
@@ -260,6 +272,9 @@ extern grpc_resource_quota_resize_type grpc_resource_quota_resize_import;
 typedef void(*grpc_resource_quota_set_max_threads_type)(grpc_resource_quota* resource_quota, int new_max_threads);
 extern grpc_resource_quota_set_max_threads_type grpc_resource_quota_set_max_threads_import;
 #define grpc_resource_quota_set_max_threads grpc_resource_quota_set_max_threads_import
+typedef grpc_slice(*grpc_dump_xds_configs_type)();
+extern grpc_dump_xds_configs_type grpc_dump_xds_configs_import;
+#define grpc_dump_xds_configs grpc_dump_xds_configs_import
 typedef const grpc_arg_pointer_vtable*(*grpc_resource_quota_arg_vtable_type)(void);
 extern grpc_resource_quota_arg_vtable_type grpc_resource_quota_arg_vtable_import;
 #define grpc_resource_quota_arg_vtable grpc_resource_quota_arg_vtable_import
@@ -284,6 +299,9 @@ extern grpc_channelz_get_subchannel_type grpc_channelz_get_subchannel_import;
 typedef char*(*grpc_channelz_get_socket_type)(intptr_t socket_id);
 extern grpc_channelz_get_socket_type grpc_channelz_get_socket_import;
 #define grpc_channelz_get_socket 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
@@ -365,6 +383,9 @@ extern grpc_max_auth_token_lifetime_type grpc_max_auth_token_lifetime_import;
 typedef grpc_call_credentials*(*grpc_service_account_jwt_access_credentials_create_type)(const char* json_key, gpr_timespec token_lifetime, void* reserved);
 extern grpc_service_account_jwt_access_credentials_create_type grpc_service_account_jwt_access_credentials_create_import;
 #define grpc_service_account_jwt_access_credentials_create grpc_service_account_jwt_access_credentials_create_import
+typedef grpc_call_credentials*(*grpc_external_account_credentials_create_type)(const char* json_string, const char* scopes_string);
+extern grpc_external_account_credentials_create_type grpc_external_account_credentials_create_import;
+#define grpc_external_account_credentials_create grpc_external_account_credentials_create_import
 typedef grpc_call_credentials*(*grpc_google_refresh_token_credentials_create_type)(const char* json_refresh_token, void* reserved);
 extern grpc_google_refresh_token_credentials_create_type grpc_google_refresh_token_credentials_create_import;
 #define grpc_google_refresh_token_credentials_create grpc_google_refresh_token_credentials_create_import
@@ -461,6 +482,9 @@ extern grpc_tls_identity_pairs_destroy_type grpc_tls_identity_pairs_destroy_impo
 typedef grpc_tls_certificate_provider*(*grpc_tls_certificate_provider_static_data_create_type)(const char* root_certificate, grpc_tls_identity_pairs* pem_key_cert_pairs);
 extern grpc_tls_certificate_provider_static_data_create_type grpc_tls_certificate_provider_static_data_create_import;
 #define grpc_tls_certificate_provider_static_data_create grpc_tls_certificate_provider_static_data_create_import
+typedef grpc_tls_certificate_provider*(*grpc_tls_certificate_provider_file_watcher_create_type)(const char* private_key_path, const char* identity_certificate_path, const char* root_cert_path, unsigned int refresh_interval_sec);
+extern grpc_tls_certificate_provider_file_watcher_create_type grpc_tls_certificate_provider_file_watcher_create_import;
+#define grpc_tls_certificate_provider_file_watcher_create grpc_tls_certificate_provider_file_watcher_create_import
 typedef void(*grpc_tls_certificate_provider_release_type)(grpc_tls_certificate_provider* provider);
 extern grpc_tls_certificate_provider_release_type grpc_tls_certificate_provider_release_import;
 #define grpc_tls_certificate_provider_release grpc_tls_certificate_provider_release_import
@@ -500,6 +524,18 @@ extern grpc_tls_server_authorization_check_config_release_type grpc_tls_server_a
 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
+typedef grpc_server_credentials*(*grpc_xds_server_credentials_create_type)(grpc_server_credentials* fallback_credentials);
+extern grpc_xds_server_credentials_create_type grpc_xds_server_credentials_create_import;
+#define grpc_xds_server_credentials_create grpc_xds_server_credentials_create_import
+typedef grpc_authorization_policy_provider*(*grpc_authorization_policy_provider_static_data_create_type)(const char* authz_policy, grpc_status_code* code, const char** error_details);
+extern grpc_authorization_policy_provider_static_data_create_type grpc_authorization_policy_provider_static_data_create_import;
+#define grpc_authorization_policy_provider_static_data_create grpc_authorization_policy_provider_static_data_create_import
+typedef grpc_authorization_policy_provider*(*grpc_authorization_policy_provider_file_watcher_create_type)(const char* authz_policy_path, unsigned int refresh_interval_sec, grpc_status_code* code, const char** error_details);
+extern grpc_authorization_policy_provider_file_watcher_create_type grpc_authorization_policy_provider_file_watcher_create_import;
+#define grpc_authorization_policy_provider_file_watcher_create grpc_authorization_policy_provider_file_watcher_create_import
+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 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
@@ -512,7 +548,7 @@ extern grpc_byte_buffer_copy_type grpc_byte_buffer_copy_import;
 typedef size_t(*grpc_byte_buffer_length_type)(grpc_byte_buffer* bb);
 extern grpc_byte_buffer_length_type grpc_byte_buffer_length_import;
 #define grpc_byte_buffer_length grpc_byte_buffer_length_import
-typedef void(*grpc_byte_buffer_destroy_type)(grpc_byte_buffer* byte_buffer);
+typedef void(*grpc_byte_buffer_destroy_type)(grpc_byte_buffer* bb);
 extern grpc_byte_buffer_destroy_type grpc_byte_buffer_destroy_import;
 #define grpc_byte_buffer_destroy grpc_byte_buffer_destroy_import
 typedef int(*grpc_byte_buffer_reader_init_type)(grpc_byte_buffer_reader* reader, grpc_byte_buffer* buffer);
@@ -680,7 +716,7 @@ extern grpc_slice_buffer_swap_type grpc_slice_buffer_swap_import;
 typedef void(*grpc_slice_buffer_move_into_type)(grpc_slice_buffer* src, grpc_slice_buffer* dst);
 extern grpc_slice_buffer_move_into_type grpc_slice_buffer_move_into_import;
 #define grpc_slice_buffer_move_into grpc_slice_buffer_move_into_import
-typedef void(*grpc_slice_buffer_trim_end_type)(grpc_slice_buffer* src, size_t n, grpc_slice_buffer* garbage);
+typedef void(*grpc_slice_buffer_trim_end_type)(grpc_slice_buffer* sb, size_t n, grpc_slice_buffer* garbage);
 extern grpc_slice_buffer_trim_end_type grpc_slice_buffer_trim_end_import;
 #define grpc_slice_buffer_trim_end grpc_slice_buffer_trim_end_import
 typedef void(*grpc_slice_buffer_move_first_type)(grpc_slice_buffer* src, size_t n, grpc_slice_buffer* dst);
@@ -692,10 +728,10 @@ extern grpc_slice_buffer_move_first_no_ref_type grpc_slice_buffer_move_first_no_
 typedef void(*grpc_slice_buffer_move_first_into_buffer_type)(grpc_slice_buffer* src, size_t n, void* dst);
 extern grpc_slice_buffer_move_first_into_buffer_type grpc_slice_buffer_move_first_into_buffer_import;
 #define grpc_slice_buffer_move_first_into_buffer grpc_slice_buffer_move_first_into_buffer_import
-typedef grpc_slice(*grpc_slice_buffer_take_first_type)(grpc_slice_buffer* src);
+typedef grpc_slice(*grpc_slice_buffer_take_first_type)(grpc_slice_buffer* sb);
 extern grpc_slice_buffer_take_first_type grpc_slice_buffer_take_first_import;
 #define grpc_slice_buffer_take_first grpc_slice_buffer_take_first_import
-typedef void(*grpc_slice_buffer_undo_take_first_type)(grpc_slice_buffer* src, grpc_slice slice);
+typedef void(*grpc_slice_buffer_undo_take_first_type)(grpc_slice_buffer* sb, grpc_slice slice);
 extern grpc_slice_buffer_undo_take_first_type grpc_slice_buffer_undo_take_first_import;
 #define grpc_slice_buffer_undo_take_first grpc_slice_buffer_undo_take_first_import
 typedef void*(*gpr_malloc_type)(size_t size);
@@ -761,7 +797,7 @@ extern gpr_cv_signal_type gpr_cv_signal_import;
 typedef void(*gpr_cv_broadcast_type)(gpr_cv* cv);
 extern gpr_cv_broadcast_type gpr_cv_broadcast_import;
 #define gpr_cv_broadcast gpr_cv_broadcast_import
-typedef void(*gpr_once_init_type)(gpr_once* once, void (*init_routine)(void));
+typedef void(*gpr_once_init_type)(gpr_once* once, void (*init_function)(void));
 extern gpr_once_init_type gpr_once_init_import;
 #define gpr_once_init gpr_once_init_import
 typedef void(*gpr_event_init_type)(gpr_event* ev);
@@ -821,7 +857,7 @@ extern gpr_time_init_type gpr_time_init_import;
 typedef gpr_timespec(*gpr_now_type)(gpr_clock_type clock);
 extern gpr_now_type gpr_now_import;
 #define gpr_now gpr_now_import
-typedef gpr_timespec(*gpr_convert_clock_type_type)(gpr_timespec t, gpr_clock_type target_clock);
+typedef gpr_timespec(*gpr_convert_clock_type_type)(gpr_timespec t, gpr_clock_type clock_type);
 extern gpr_convert_clock_type_type gpr_convert_clock_type_import;
 #define gpr_convert_clock_type gpr_convert_clock_type_import
 typedef int(*gpr_time_cmp_type)(gpr_timespec a, gpr_timespec b);
@@ -839,22 +875,22 @@ extern gpr_time_add_type gpr_time_add_import;
 typedef gpr_timespec(*gpr_time_sub_type)(gpr_timespec a, gpr_timespec b);
 extern gpr_time_sub_type gpr_time_sub_import;
 #define gpr_time_sub gpr_time_sub_import
-typedef gpr_timespec(*gpr_time_from_micros_type)(int64_t x, gpr_clock_type clock_type);
+typedef gpr_timespec(*gpr_time_from_micros_type)(int64_t us, gpr_clock_type clock_type);
 extern gpr_time_from_micros_type gpr_time_from_micros_import;
 #define gpr_time_from_micros gpr_time_from_micros_import
-typedef gpr_timespec(*gpr_time_from_nanos_type)(int64_t x, gpr_clock_type clock_type);
+typedef gpr_timespec(*gpr_time_from_nanos_type)(int64_t ns, gpr_clock_type clock_type);
 extern gpr_time_from_nanos_type gpr_time_from_nanos_import;
 #define gpr_time_from_nanos gpr_time_from_nanos_import
-typedef gpr_timespec(*gpr_time_from_millis_type)(int64_t x, gpr_clock_type clock_type);
+typedef gpr_timespec(*gpr_time_from_millis_type)(int64_t ms, gpr_clock_type clock_type);
 extern gpr_time_from_millis_type gpr_time_from_millis_import;
 #define gpr_time_from_millis gpr_time_from_millis_import
-typedef gpr_timespec(*gpr_time_from_seconds_type)(int64_t x, gpr_clock_type clock_type);
+typedef gpr_timespec(*gpr_time_from_seconds_type)(int64_t s, gpr_clock_type clock_type);
 extern gpr_time_from_seconds_type gpr_time_from_seconds_import;
 #define gpr_time_from_seconds gpr_time_from_seconds_import
-typedef gpr_timespec(*gpr_time_from_minutes_type)(int64_t x, gpr_clock_type clock_type);
+typedef gpr_timespec(*gpr_time_from_minutes_type)(int64_t m, gpr_clock_type clock_type);
 extern gpr_time_from_minutes_type gpr_time_from_minutes_import;
 #define gpr_time_from_minutes gpr_time_from_minutes_import
-typedef gpr_timespec(*gpr_time_from_hours_type)(int64_t x, gpr_clock_type clock_type);
+typedef gpr_timespec(*gpr_time_from_hours_type)(int64_t h, gpr_clock_type clock_type);
 extern gpr_time_from_hours_type gpr_time_from_hours_import;
 #define gpr_time_from_hours gpr_time_from_hours_import
 typedef int32_t(*gpr_time_to_millis_type)(gpr_timespec timespec);

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

@@ -18,19 +18,21 @@
 
 #include <ruby/ruby.h>
 
-#include "rb_grpc_imports.generated.h"
 #include "rb_server.h"
 
-#include <grpc/grpc.h>
-#include <grpc/grpc_security.h>
-#include <grpc/support/atm.h>
-#include <grpc/support/log.h>
 #include "rb_byte_buffer.h"
 #include "rb_call.h"
 #include "rb_channel_args.h"
 #include "rb_completion_queue.h"
 #include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
 #include "rb_server_credentials.h"
+#include "rb_xds_server_credentials.h"
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/atm.h>
+#include <grpc/support/log.h>
 
 /* grpc_rb_cServer is the ruby class that proxies grpc_server. */
 static VALUE grpc_rb_cServer = Qnil;
@@ -326,7 +328,18 @@ static VALUE grpc_rb_server_add_http2_port(VALUE self, VALUE port,
                StringValueCStr(port));
     }
   } else {
-    creds = grpc_rb_get_wrapped_server_credentials(rb_creds);
+    // TODO: create a common parent class for all server-side credentials,
+    // then we can have a single method to retrieve the underlying
+    // grpc_server_credentials object, and avoid the need for this reflection
+    if (grpc_rb_is_server_credentials(rb_creds)) {
+      creds = grpc_rb_get_wrapped_server_credentials(rb_creds);
+    } else if (grpc_rb_is_xds_server_credentials(rb_creds)) {
+      creds = grpc_rb_get_wrapped_xds_server_credentials(rb_creds);
+    } else {
+      rb_raise(rb_eTypeError,
+               "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);
     if (recvd_port == 0) {

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

@@ -18,15 +18,15 @@
 
 #include <ruby/ruby.h>
 
-#include "rb_grpc_imports.generated.h"
 #include "rb_server_credentials.h"
 
+#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
+
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/support/log.h>
 
-#include "rb_grpc.h"
-
 /* grpc_rb_cServerCredentials is the ruby class that proxies
    grpc_server_credentials. */
 static VALUE grpc_rb_cServerCredentials = Qnil;
@@ -42,7 +42,7 @@ typedef struct grpc_rb_server_credentials {
 } grpc_rb_server_credentials;
 
 /* Destroys the server credentials instances. */
-static void grpc_rb_server_credentials_free(void* p) {
+static void grpc_rb_server_credentials_free_internal(void* p) {
   grpc_rb_server_credentials* wrapper = NULL;
   if (p == NULL) {
     return;
@@ -59,6 +59,12 @@ static void grpc_rb_server_credentials_free(void* p) {
   xfree(p);
 }
 
+/* Destroys the server credentials instances. */
+static void grpc_rb_server_credentials_free(void* p) {
+  grpc_rb_server_credentials_free_internal(p);
+  grpc_ruby_shutdown();
+}
+
 /* Protects the mark object from GC */
 static void grpc_rb_server_credentials_mark(void* p) {
   grpc_rb_server_credentials* wrapper = NULL;
@@ -87,9 +93,9 @@ static const rb_data_type_t grpc_rb_server_credentials_data_type = {
 };
 
 /* Allocates ServerCredential instances.
-
    Provides safe initial defaults for the instance fields. */
 static VALUE grpc_rb_server_credentials_alloc(VALUE cls) {
+  grpc_ruby_init();
   grpc_rb_server_credentials* wrapper = ALLOC(grpc_rb_server_credentials);
   wrapper->wrapped = NULL;
   wrapper->mark = Qnil;
@@ -202,7 +208,11 @@ static VALUE grpc_rb_server_credentials_init(VALUE self, VALUE pem_root_certs,
   }
   xfree(key_cert_pairs);
   if (creds == NULL) {
-    rb_raise(rb_eRuntimeError, "could not create a credentials, not sure why");
+    rb_raise(rb_eRuntimeError,
+             "the call to grpc_ssl_server_credentials_create_ex() failed, "
+             "could not create a credentials, see "
+             "https://github.com/grpc/grpc/blob/master/TROUBLESHOOTING.md for "
+             "debugging tips");
     return Qnil;
   }
   wrapper->wrapped = creds;
@@ -237,7 +247,13 @@ void Init_grpc_server_credentials() {
 /* Gets the wrapped grpc_server_credentials from the ruby wrapper */
 grpc_server_credentials* grpc_rb_get_wrapped_server_credentials(VALUE v) {
   grpc_rb_server_credentials* wrapper = NULL;
+  Check_TypedStruct(v, &grpc_rb_server_credentials_data_type);
   TypedData_Get_Struct(v, grpc_rb_server_credentials,
                        &grpc_rb_server_credentials_data_type, wrapper);
   return wrapper->wrapped;
 }
+
+/* Check if v is kind of ServerCredentials */
+bool grpc_rb_is_server_credentials(VALUE v) {
+  return rb_typeddata_is_kind_of(v, &grpc_rb_server_credentials_data_type);
+}

data/src/ruby/ext/grpc/rb_server_credentials.h

@@ -21,6 +21,8 @@
 
 #include <ruby/ruby.h>
 
+#include <stdbool.h>
+
 #include <grpc/grpc_security.h>
 
 /* Initializes the ruby ServerCredentials class. */
@@ -29,4 +31,7 @@ void Init_grpc_server_credentials();
 /* Gets the wrapped server_credentials from the ruby wrapper */
 grpc_server_credentials* grpc_rb_get_wrapped_server_credentials(VALUE v);
 
+/* Check if v is kind of ServerCredentials */
+bool grpc_rb_is_server_credentials(VALUE v);
+
 #endif /* GRPC_RB_SERVER_CREDENTIALS_H_ */

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

@@ -0,0 +1,218 @@
+/*
+ *
+ * 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 <ruby/ruby.h>
+
+#include "rb_xds_channel_credentials.h"
+
+#include <string.h>
+
+#include "rb_call_credentials.h"
+#include "rb_channel_credentials.h"
+#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+/* grpc_rb_cXdsChannelCredentials is the ruby class that proxies
+   grpc_channel_credentials. */
+static VALUE grpc_rb_cXdsChannelCredentials = Qnil;
+
+/* grpc_rb_xds_channel_credentials wraps a grpc_channel_credentials.  It
+ * provides a mark object that is used to hold references to any objects used to
+ * create the credentials. */
+typedef struct grpc_rb_xds_channel_credentials {
+  /* Holder of ruby objects involved in constructing the credentials */
+  VALUE mark;
+
+  /* The actual credentials */
+  grpc_channel_credentials* wrapped;
+} grpc_rb_xds_channel_credentials;
+
+static void grpc_rb_xds_channel_credentials_free_internal(void* p) {
+  grpc_rb_xds_channel_credentials* wrapper = NULL;
+  if (p == NULL) {
+    return;
+  };
+  wrapper = (grpc_rb_xds_channel_credentials*)p;
+  grpc_channel_credentials_release(wrapper->wrapped);
+  wrapper->wrapped = NULL;
+
+  xfree(p);
+}
+
+/* Destroys the credentials instances. */
+static void grpc_rb_xds_channel_credentials_free(void* p) {
+  grpc_rb_xds_channel_credentials_free_internal(p);
+  grpc_ruby_shutdown();
+}
+
+/* Protects the mark object from GC */
+static void grpc_rb_xds_channel_credentials_mark(void* p) {
+  grpc_rb_xds_channel_credentials* wrapper = NULL;
+  if (p == NULL) {
+    return;
+  }
+  wrapper = (grpc_rb_xds_channel_credentials*)p;
+
+  if (wrapper->mark != Qnil) {
+    rb_gc_mark(wrapper->mark);
+  }
+}
+
+static rb_data_type_t grpc_rb_xds_channel_credentials_data_type = {
+    "grpc_xds_channel_credentials",
+    {grpc_rb_xds_channel_credentials_mark, grpc_rb_xds_channel_credentials_free,
+     GRPC_RB_MEMSIZE_UNAVAILABLE, NULL},
+    NULL,
+    NULL,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
+/* Allocates ChannelCredential instances.
+   Provides safe initial defaults for the instance fields. */
+static VALUE grpc_rb_xds_channel_credentials_alloc(VALUE cls) {
+  grpc_ruby_init();
+  grpc_rb_xds_channel_credentials* wrapper =
+      ALLOC(grpc_rb_xds_channel_credentials);
+  wrapper->wrapped = NULL;
+  wrapper->mark = Qnil;
+  return TypedData_Wrap_Struct(cls, &grpc_rb_xds_channel_credentials_data_type,
+                               wrapper);
+}
+
+/* Creates a wrapping object for a given channel credentials. This should only
+ * be called with grpc_channel_credentials objects that are not already
+ * associated with any Ruby object. */
+VALUE grpc_rb_xds_wrap_channel_credentials(grpc_channel_credentials* c,
+                                           VALUE mark) {
+  grpc_rb_xds_channel_credentials* wrapper;
+  if (c == NULL) {
+    return Qnil;
+  }
+  VALUE rb_wrapper =
+      grpc_rb_xds_channel_credentials_alloc(grpc_rb_cXdsChannelCredentials);
+  TypedData_Get_Struct(rb_wrapper, grpc_rb_xds_channel_credentials,
+                       &grpc_rb_xds_channel_credentials_data_type, wrapper);
+  wrapper->wrapped = c;
+  wrapper->mark = mark;
+  return rb_wrapper;
+}
+
+/* The attribute used on the mark object to hold the fallback creds. */
+static ID id_fallback_creds;
+
+/*
+  call-seq:
+    fallback_creds: (ChannelCredentials) fallback credentials to create
+    XDS credentials
+    Initializes Credential instances. */
+static VALUE grpc_rb_xds_channel_credentials_init(VALUE self,
+                                                  VALUE fallback_creds) {
+  grpc_rb_xds_channel_credentials* wrapper = NULL;
+  grpc_channel_credentials* grpc_fallback_creds =
+      grpc_rb_get_wrapped_channel_credentials(fallback_creds);
+  grpc_channel_credentials* creds =
+      grpc_xds_credentials_create(grpc_fallback_creds);
+  if (creds == NULL) {
+    rb_raise(rb_eRuntimeError,
+             "the call to grpc_xds_credentials_create() failed, could not "
+             "create a credentials, , see "
+             "https://github.com/grpc/grpc/blob/master/TROUBLESHOOTING.md for "
+             "debugging tips");
+    return Qnil;
+  }
+
+  TypedData_Get_Struct(self, grpc_rb_xds_channel_credentials,
+                       &grpc_rb_xds_channel_credentials_data_type, wrapper);
+  wrapper->wrapped = creds;
+
+  /* Add the input objects as hidden fields to preserve them. */
+  rb_ivar_set(self, id_fallback_creds, fallback_creds);
+
+  return self;
+}
+
+// TODO: de-duplicate this code with the similar method in
+// rb_channel_credentials.c, after putting ChannelCredentials and
+// XdsChannelCredentials under a common parent class
+static VALUE grpc_rb_xds_channel_credentials_compose(int argc, VALUE* argv,
+                                                     VALUE self) {
+  grpc_channel_credentials* creds;
+  grpc_call_credentials* other;
+  grpc_channel_credentials* prev = NULL;
+  VALUE mark;
+  if (argc == 0) {
+    return self;
+  }
+  mark = rb_ary_new();
+  rb_ary_push(mark, self);
+  creds = grpc_rb_get_wrapped_xds_channel_credentials(self);
+  for (int i = 0; i < argc; i++) {
+    rb_ary_push(mark, argv[i]);
+    other = grpc_rb_get_wrapped_call_credentials(argv[i]);
+    creds = grpc_composite_channel_credentials_create(creds, other, NULL);
+    if (prev != NULL) {
+      grpc_channel_credentials_release(prev);
+    }
+    prev = creds;
+
+    if (creds == NULL) {
+      rb_raise(rb_eRuntimeError,
+               "Failed to compose channel and call credentials");
+    }
+  }
+  return grpc_rb_xds_wrap_channel_credentials(creds, mark);
+}
+
+void Init_grpc_xds_channel_credentials() {
+  grpc_rb_cXdsChannelCredentials = rb_define_class_under(
+      grpc_rb_mGrpcCore, "XdsChannelCredentials", rb_cObject);
+
+  /* Allocates an object managed by the ruby runtime */
+  rb_define_alloc_func(grpc_rb_cXdsChannelCredentials,
+                       grpc_rb_xds_channel_credentials_alloc);
+
+  /* Provides a ruby constructor and support for dup/clone. */
+  rb_define_method(grpc_rb_cXdsChannelCredentials, "initialize",
+                   grpc_rb_xds_channel_credentials_init, 1);
+  rb_define_method(grpc_rb_cXdsChannelCredentials, "initialize_copy",
+                   grpc_rb_cannot_init_copy, 1);
+  rb_define_method(grpc_rb_cXdsChannelCredentials, "compose",
+                   grpc_rb_xds_channel_credentials_compose, -1);
+
+  id_fallback_creds = rb_intern("__fallback_creds");
+}
+
+/* Gets the wrapped grpc_channel_credentials from the ruby wrapper */
+grpc_channel_credentials* grpc_rb_get_wrapped_xds_channel_credentials(VALUE v) {
+  grpc_rb_xds_channel_credentials* wrapper = NULL;
+  Check_TypedStruct(v, &grpc_rb_xds_channel_credentials_data_type);
+  TypedData_Get_Struct(v, grpc_rb_xds_channel_credentials,
+                       &grpc_rb_xds_channel_credentials_data_type, wrapper);
+  return wrapper->wrapped;
+}
+
+bool grpc_rb_is_xds_channel_credentials(VALUE v) {
+  return rb_typeddata_is_kind_of(v, &grpc_rb_xds_channel_credentials_data_type);
+}

data/src/ruby/ext/grpc/rb_xds_channel_credentials.h

@@ -0,0 +1,37 @@
+/*
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_RB_XDS_CHANNEL_CREDENTIALS_H_
+#define GRPC_RB_XDS_CHANNEL_CREDENTIALS_H_
+
+#include <ruby/ruby.h>
+
+#include <stdbool.h>
+
+#include <grpc/grpc_security.h>
+
+/* Initializes the ruby ChannelCredentials class. */
+void Init_grpc_xds_channel_credentials();
+
+/* Gets the wrapped credentials from the ruby wrapper */
+grpc_channel_credentials* grpc_rb_get_wrapped_xds_channel_credentials(VALUE v);
+
+/* Check if v is kind of XdsChannelCredentials */
+bool grpc_rb_is_xds_channel_credentials(VALUE v);
+
+#endif /* GRPC_RB_XDS_CHANNEL_CREDENTIALS_H_ */