grpc 1.35.0.pre1-x86-linux → 1.37.1-x86-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c58c9ef47006336a84c6bbb07869fcbbc465d1e136034f36b6683dcdc9545d50
-  data.tar.gz: f0b986d32a0e26c967d369e50799b08044609401f2b9438ee8c6d7655dff8a91
+  metadata.gz: 2598c10f0d43edc7f28deaec43891ded86cfed8ceef31804f15b794ba8cb7d8b
+  data.tar.gz: da47fdffa56f81f2df9c4840117f5f2bd2b866d77c1b3d5e1428dc99bbd71f13
 SHA512:
-  metadata.gz: 673691452a29a46944040ef3cf03e0678b41eae1bf1c6a51d4b61f65d2a4f0b5c303bf994c78d6cfae8c6f00cbd9c6b4246e126dc8ca7fe2d9349330ec8786a3
-  data.tar.gz: f58ce6e3416a13b9356693c53a1e65382ec9a835eba940d90bac9e6e17fab8ec9f4afacd769855d04aba15981ac8f46f99b1a4b40cc97724d6c5fdb8aa3c7c81
+  metadata.gz: 818c278e3e575f5194f8f5b15991e7d1a29310433dee1869e0a21c32877941d4397f00d64305b459d6628a4af7d1ef1284c6407c3bb91276835b3b9cdd133268
+  data.tar.gz: 9400df0276785ff23cfb00976e437f059c99edc95daa2bf0420ee33f5730085a8e582c92a4cdd0bc6a03ab0e30013f13c8a68b975b4bd6ba278a7db77a5b8687

data/src/ruby/ext/grpc/extconf.rb

@@ -45,8 +45,16 @@ if RUBY_PLATFORM =~ /darwin/
 ENV['EMBED_OPENSSL'] = 'true'
 ENV['EMBED_ZLIB'] = 'true'
 ENV['EMBED_CARES'] = 'true'
+
 ENV['ARCH_FLAGS'] = RbConfig::CONFIG['ARCH_FLAG']
-ENV['ARCH_FLAGS'] = '-arch i386 -arch x86_64' if RUBY_PLATFORM =~ /darwin/
+if RUBY_PLATFORM =~ /darwin/
+  if RUBY_PLATFORM =~ /arm64/
+    ENV['ARCH_FLAGS'] = '-arch arm64'
+  else
+    ENV['ARCH_FLAGS'] = '-arch i386 -arch x86_64'
+  end
+end
+
 ENV['CPPFLAGS'] = '-DGPR_BACKWARDS_COMPATIBILITY_MODE'
 
 output_dir = File.expand_path(RbConfig::CONFIG['topdir'])

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

@@ -34,6 +34,7 @@
 #include "rb_completion_queue.h"
 #include "rb_grpc.h"
 #include "rb_server.h"
+#include "rb_xds_channel_credentials.h"
 
 /* id_channel is the name of the hidden ivar that preserves a reference to the
  * channel on a call, so that calls are not GCed before their channel.  */
@@ -242,7 +243,15 @@ static VALUE grpc_rb_channel_init(int argc, VALUE* argv, VALUE self) {
     ch = grpc_insecure_channel_create(target_chars, &args, NULL);
   } else {
     wrapper->credentials = credentials;
-    creds = grpc_rb_get_wrapped_channel_credentials(credentials);
+    if (grpc_rb_is_channel_credentials(credentials)) {
+      creds = grpc_rb_get_wrapped_channel_credentials(credentials);
+    } else if (grpc_rb_is_xds_channel_credentials(credentials)) {
+      creds = grpc_rb_get_wrapped_xds_channel_credentials(credentials);
+    } else {
+      rb_raise(rb_eTypeError,
+               "bad creds, want ChannelCredentials or XdsChannelCredentials");
+      return Qnil;
+    }
     ch = grpc_secure_channel_create(creds, target_chars, &args, NULL);
   }
 

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

@@ -180,7 +180,11 @@ static VALUE grpc_rb_channel_credentials_init(int argc, VALUE* argv,
                                         NULL, NULL);
   }
   if (creds == NULL) {
-    rb_raise(rb_eRuntimeError, "could not create a credentials, not sure why");
+    rb_raise(rb_eRuntimeError,
+             "the call to grpc_ssl_credentials_create() failed, could not "
+             "create a credentials, see "
+             "https://github.com/grpc/grpc/blob/master/TROUBLESHOOTING.md for "
+             "debugging tips");
     return Qnil;
   }
   wrapper->wrapped = creds;
@@ -270,7 +274,13 @@ void Init_grpc_channel_credentials() {
 /* Gets the wrapped grpc_channel_credentials from the ruby wrapper */
 grpc_channel_credentials* grpc_rb_get_wrapped_channel_credentials(VALUE v) {
   grpc_rb_channel_credentials* wrapper = NULL;
+  Check_TypedStruct(v, &grpc_rb_channel_credentials_data_type);
   TypedData_Get_Struct(v, grpc_rb_channel_credentials,
                        &grpc_rb_channel_credentials_data_type, wrapper);
   return wrapper->wrapped;
 }
+
+/* Check if v is kind of ChannelCredentials */
+bool grpc_rb_is_channel_credentials(VALUE v) {
+  return rb_typeddata_is_kind_of(v, &grpc_rb_channel_credentials_data_type);
+}

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

@@ -20,6 +20,7 @@
 #define GRPC_RB_CREDENTIALS_H_
 
 #include <ruby/ruby.h>
+#include <stdbool.h>
 
 #include <grpc/grpc_security.h>
 
@@ -29,4 +30,7 @@ void Init_grpc_channel_credentials();
 /* Gets the wrapped credentials from the ruby wrapper */
 grpc_channel_credentials* grpc_rb_get_wrapped_channel_credentials(VALUE v);
 
+/* Check if v is kind of ChannelCredentials */
+bool grpc_rb_is_channel_credentials(VALUE v);
+
 #endif /* GRPC_RB_CREDENTIALS_H_ */

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

@@ -142,7 +142,7 @@ grpc_compression_level grpc_rb_compression_options_level_name_to_value_internal(
            "Unrecognized compression level name."
            "Valid compression level names are none, low, medium, and high.");
 
-  /* Dummy return statement. */
+  /* Phony return statement. */
   return GRPC_COMPRESS_LEVEL_NONE;
 }
 

data/src/ruby/ext/grpc/rb_enable_cpp.cc

@@ -18,5 +18,5 @@
 
 #include <ruby/ruby.h>
 
-// This is a dummy C++ source file to trigger ruby extension builder to
+// This is a phony C++ source file to trigger ruby extension builder to
 // pick C++ rather than C linker to link with c++ library properly.

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

@@ -40,6 +40,8 @@
 #include "rb_loader.h"
 #include "rb_server.h"
 #include "rb_server_credentials.h"
+#include "rb_xds_channel_credentials.h"
+#include "rb_xds_server_credentials.h"
 
 static VALUE grpc_rb_cTimeVal = Qnil;
 
@@ -321,8 +323,10 @@ void Init_grpc_c() {
   Init_grpc_call();
   Init_grpc_call_credentials();
   Init_grpc_channel_credentials();
+  Init_grpc_xds_channel_credentials();
   Init_grpc_server();
   Init_grpc_server_credentials();
+  Init_grpc_xds_server_credentials();
   Init_grpc_time_consts();
   Init_grpc_compression_options();
 }

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

@@ -98,6 +98,7 @@ grpc_resource_quota_ref_type grpc_resource_quota_ref_import;
 grpc_resource_quota_unref_type grpc_resource_quota_unref_import;
 grpc_resource_quota_resize_type grpc_resource_quota_resize_import;
 grpc_resource_quota_set_max_threads_type grpc_resource_quota_set_max_threads_import;
+grpc_dump_xds_configs_type grpc_dump_xds_configs_import;
 grpc_resource_quota_arg_vtable_type grpc_resource_quota_arg_vtable_import;
 grpc_channelz_get_top_channels_type grpc_channelz_get_top_channels_import;
 grpc_channelz_get_servers_type grpc_channelz_get_servers_import;
@@ -382,6 +383,7 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_resource_quota_unref_import = (grpc_resource_quota_unref_type) GetProcAddress(library, "grpc_resource_quota_unref");
   grpc_resource_quota_resize_import = (grpc_resource_quota_resize_type) GetProcAddress(library, "grpc_resource_quota_resize");
   grpc_resource_quota_set_max_threads_import = (grpc_resource_quota_set_max_threads_type) GetProcAddress(library, "grpc_resource_quota_set_max_threads");
+  grpc_dump_xds_configs_import = (grpc_dump_xds_configs_type) GetProcAddress(library, "grpc_dump_xds_configs");
   grpc_resource_quota_arg_vtable_import = (grpc_resource_quota_arg_vtable_type) GetProcAddress(library, "grpc_resource_quota_arg_vtable");
   grpc_channelz_get_top_channels_import = (grpc_channelz_get_top_channels_type) GetProcAddress(library, "grpc_channelz_get_top_channels");
   grpc_channelz_get_servers_import = (grpc_channelz_get_servers_type) GetProcAddress(library, "grpc_channelz_get_servers");

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

@@ -215,7 +215,7 @@ 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)();
+typedef grpc_server_config_fetcher*(*grpc_server_config_fetcher_xds_create_type)(grpc_server_xds_status_notifier notifier);
 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);
@@ -269,6 +269,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

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

@@ -31,6 +31,7 @@
 #include "rb_completion_queue.h"
 #include "rb_grpc.h"
 #include "rb_server_credentials.h"
+#include "rb_xds_server_credentials.h"
 
 /* grpc_rb_cServer is the ruby class that proxies grpc_server. */
 static VALUE grpc_rb_cServer = Qnil;
@@ -326,7 +327,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

@@ -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

@@ -20,6 +20,7 @@
 #define GRPC_RB_SERVER_CREDENTIALS_H_
 
 #include <ruby/ruby.h>
+#include <stdbool.h>
 
 #include <grpc/grpc_security.h>
 
@@ -29,4 +30,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,215 @@
+/*
+ *
+ * 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/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <ruby/ruby.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 "rb_xds_channel_credentials.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);
+}