grpc 1.34.0-x64-mingw32 → 1.37.0-x64-mingw32

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);
+}

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

@@ -0,0 +1,35 @@
+/*
+ *
+ * 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 <grpc/grpc_security.h>
+#include <ruby/ruby.h>
+#include <stdbool.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_ */

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

@@ -0,0 +1,169 @@
+/*
+ *
+ * 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 "rb_xds_server_credentials.h"
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/log.h>
+#include <ruby/ruby.h>
+
+#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
+#include "rb_server_credentials.h"
+
+/* grpc_rb_cXdsServerCredentials is the ruby class that proxies
+   grpc_server_credentials. */
+static VALUE grpc_rb_cXdsServerCredentials = Qnil;
+
+/* grpc_rb_xds_server_credentials wraps a grpc_server_credentials.  It provides
+   a peer ruby object, 'mark' to hold references to objects involved in
+   constructing the server credentials. */
+typedef struct grpc_rb_xds_server_credentials {
+  /* Holder of ruby objects involved in constructing the server credentials */
+  VALUE mark;
+  /* The actual server credentials */
+  grpc_server_credentials* wrapped;
+} grpc_rb_xds_server_credentials;
+
+/* Destroys the server credentials instances. */
+static void grpc_rb_xds_server_credentials_free_internal(void* p) {
+  grpc_rb_xds_server_credentials* wrapper = NULL;
+  if (p == NULL) {
+    return;
+  };
+  wrapper = (grpc_rb_xds_server_credentials*)p;
+
+  /* Delete the wrapped object if the mark object is Qnil, which indicates that
+     no other object is the actual owner. */
+  if (wrapper->wrapped != NULL && wrapper->mark == Qnil) {
+    grpc_server_credentials_release(wrapper->wrapped);
+    wrapper->wrapped = NULL;
+  }
+
+  xfree(p);
+}
+
+/* Destroys the server credentials instances. */
+static void grpc_rb_xds_server_credentials_free(void* p) {
+  grpc_rb_xds_server_credentials_free_internal(p);
+  grpc_ruby_shutdown();
+}
+
+/* Protects the mark object from GC */
+static void grpc_rb_xds_server_credentials_mark(void* p) {
+  if (p == NULL) {
+    return;
+  }
+  grpc_rb_xds_server_credentials* wrapper = (grpc_rb_xds_server_credentials*)p;
+
+  /* If it's not already cleaned up, mark the mark object */
+  if (wrapper->mark != Qnil) {
+    rb_gc_mark(wrapper->mark);
+  }
+}
+
+static const rb_data_type_t grpc_rb_xds_server_credentials_data_type = {
+    "grpc_xds_server_credentials",
+    {grpc_rb_xds_server_credentials_mark, grpc_rb_xds_server_credentials_free,
+     GRPC_RB_MEMSIZE_UNAVAILABLE, NULL},
+    NULL,
+    NULL,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
+/* Allocates ServerCredential instances.
+   Provides safe initial defaults for the instance fields. */
+static VALUE grpc_rb_xds_server_credentials_alloc(VALUE cls) {
+  grpc_ruby_init();
+  grpc_rb_xds_server_credentials* wrapper =
+      ALLOC(grpc_rb_xds_server_credentials);
+  wrapper->wrapped = NULL;
+  wrapper->mark = Qnil;
+  return TypedData_Wrap_Struct(cls, &grpc_rb_xds_server_credentials_data_type,
+                               wrapper);
+}
+
+/* The attribute used on the mark object to preserve the fallback_creds. */
+static ID id_fallback_creds;
+
+/*
+  call-seq:
+    creds = ServerCredentials.new(fallback_creds)
+    fallback_creds: (ServerCredentials) fallback credentials to create
+                    XDS credentials.
+    Initializes ServerCredential instances. */
+static VALUE grpc_rb_xds_server_credentials_init(VALUE self,
+                                                 VALUE fallback_creds) {
+  grpc_rb_xds_server_credentials* wrapper = NULL;
+  grpc_server_credentials* creds = NULL;
+
+  grpc_server_credentials* grpc_fallback_creds =
+      grpc_rb_get_wrapped_server_credentials(fallback_creds);
+  creds = grpc_xds_server_credentials_create(grpc_fallback_creds);
+
+  if (creds == NULL) {
+    rb_raise(rb_eRuntimeError,
+             "the call to grpc_xds_server_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_server_credentials,
+                       &grpc_rb_xds_server_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;
+}
+
+void Init_grpc_xds_server_credentials() {
+  grpc_rb_cXdsServerCredentials = rb_define_class_under(
+      grpc_rb_mGrpcCore, "XdsServerCredentials", rb_cObject);
+
+  /* Allocates an object managed by the ruby runtime */
+  rb_define_alloc_func(grpc_rb_cXdsServerCredentials,
+                       grpc_rb_xds_server_credentials_alloc);
+
+  /* Provides a ruby constructor and support for dup/clone. */
+  rb_define_method(grpc_rb_cXdsServerCredentials, "initialize",
+                   grpc_rb_xds_server_credentials_init, 1);
+  rb_define_method(grpc_rb_cXdsServerCredentials, "initialize_copy",
+                   grpc_rb_cannot_init_copy, 1);
+
+  id_fallback_creds = rb_intern("__fallback_creds");
+}
+
+/* Gets the wrapped grpc_server_credentials from the ruby wrapper */
+grpc_server_credentials* grpc_rb_get_wrapped_xds_server_credentials(VALUE v) {
+  grpc_rb_xds_server_credentials* wrapper = NULL;
+  Check_TypedStruct(v, &grpc_rb_xds_server_credentials_data_type);
+  TypedData_Get_Struct(v, grpc_rb_xds_server_credentials,
+                       &grpc_rb_xds_server_credentials_data_type, wrapper);
+  return wrapper->wrapped;
+}
+
+/* Check if v is kind of ServerCredentials */
+bool grpc_rb_is_xds_server_credentials(VALUE v) {
+  return rb_typeddata_is_kind_of(v, &grpc_rb_xds_server_credentials_data_type);
+}

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

@@ -0,0 +1,35 @@
+/*
+ *
+ * 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_SERVER_CREDENTIALS_H_
+#define GRPC_RB_XDS_SERVER_CREDENTIALS_H_
+
+#include <grpc/grpc_security.h>
+#include <ruby/ruby.h>
+#include <stdbool.h>
+
+/* Initializes the ruby XdsServerCredentials class. */
+void Init_grpc_xds_server_credentials();
+
+/* Gets the wrapped server_credentials from the ruby wrapper */
+grpc_server_credentials* grpc_rb_get_wrapped_xds_server_credentials(VALUE v);
+
+/* Check if v is kind of XdsServerCredentials */
+bool grpc_rb_is_xds_server_credentials(VALUE v);
+
+#endif /* GRPC_RB_XDS_SERVER_CREDENTIALS_H_ */