Chiebot-Mirror
/
grpc
mirror of https://github.com/grpc/grpc.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Updates channel credentials

Browse Source 
- switches credentials to channel credentials
- removes usages of other credentials classes that would are not
  currently used in the ruby surface
reviewable/pr3765/r1^2
Tim Emiola 9 years ago
parent 276266d0b0
commit 9332ea6af5
4 changed files with 62 additions and 131 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      src/ruby/ext/grpc/rb_channel.c
  2. 177
      src/ruby/ext/grpc/rb_channel_credentials.c
  3. 6
      src/ruby/ext/grpc/rb_channel_credentials.h
  4. 4
      src/ruby/ext/grpc/rb_grpc.c

6
src/ruby/ext/grpc/rb_channel.c
Unescape View File

@ -41,8 +41,8 @@
#include "rb_grpc.h"
#include "rb_call.h"
#include "rb_channel_args.h"
#include "rb_channel_credentials.h"
#include "rb_completion_queue.h"
#include "rb_credentials.h"
#include "rb_server.h"
/* id_channel is the name of the hidden ivar that preserves a reference to the
@ -134,8 +134,8 @@ static VALUE grpc_rb_channel_init(int argc, VALUE *argv, VALUE self) {
VALUE credentials = Qnil;
VALUE target = Qnil;
grpc_rb_channel *wrapper = NULL;
grpc_credentials *creds = NULL;
grpc_channel *ch = NULL;
grpc_channel_credentials *creds = NULL;
char *target_chars = NULL;
grpc_channel_args args;
MEMZERO(&args, grpc_channel_args, 1);
@ -149,7 +149,7 @@ static VALUE grpc_rb_channel_init(int argc, VALUE *argv, VALUE self) {
if (credentials == Qnil) {
ch = grpc_insecure_channel_create(target_chars, &args, NULL);
} else {
creds = grpc_rb_get_wrapped_credentials(credentials);
creds = grpc_rb_get_wrapped_channel_credentials(credentials);
ch = grpc_secure_channel_create(creds, target_chars, &args, NULL);
}
if (args.args != NULL) {

177
src/ruby/ext/grpc/rb_credentials.c → src/ruby/ext/grpc/rb_channel_credentials.c
Unescape View File

@ -31,7 +31,7 @@
*
*/
#include "rb_credentials.h"
#include "rb_channel_credentials.h"
#include <ruby/ruby.h>
@ -40,32 +40,33 @@
#include "rb_grpc.h"
/* grpc_rb_cCredentials is the ruby class that proxies grpc_credentials. */
static VALUE grpc_rb_cCredentials = Qnil;
/* grpc_rb_cChannelCredentials is the ruby class that proxies
grpc_channel_credentials. */
static VALUE grpc_rb_cChannelCredentials = Qnil;
/* grpc_rb_credentials wraps a grpc_credentials. It provides a
/* grpc_rb_channel_credentials wraps a grpc_channel_credentials. It provides a
* peer ruby object, 'mark' to minimize copying when a credential is
* created from ruby. */
typedef struct grpc_rb_credentials {
typedef struct grpc_rb_channel_credentials {
/* Holder of ruby objects involved in constructing the credentials */
VALUE mark;
/* The actual credentials */
grpc_credentials *wrapped;
} grpc_rb_credentials;
grpc_channel_credentials *wrapped;
} grpc_rb_channel_credentials;
/* Destroys the credentials instances. */
static void grpc_rb_credentials_free(void *p) {
grpc_rb_credentials *wrapper = NULL;
static void grpc_rb_channel_credentials_free(void *p) {
grpc_rb_channel_credentials *wrapper = NULL;
if (p == NULL) {
return;
};
wrapper = (grpc_rb_credentials *)p;
wrapper = (grpc_rb_channel_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_credentials_release(wrapper->wrapped);
grpc_channel_credentials_release(wrapper->wrapped);
wrapper->wrapped = NULL;
}
@ -73,12 +74,12 @@ static void grpc_rb_credentials_free(void *p) {
}
/* Protects the mark object from GC */
static void grpc_rb_credentials_mark(void *p) {
grpc_rb_credentials *wrapper = NULL;
static void grpc_rb_channel_credentials_mark(void *p) {
grpc_rb_channel_credentials *wrapper = NULL;
if (p == NULL) {
return;
}
wrapper = (grpc_rb_credentials *)p;
wrapper = (grpc_rb_channel_credentials *)p;
/* If it's not already cleaned up, mark the mark object */
if (wrapper->mark != Qnil) {
@ -86,29 +87,29 @@ static void grpc_rb_credentials_mark(void *p) {
}
}
static rb_data_type_t grpc_rb_credentials_data_type = {
"grpc_credentials",
{grpc_rb_credentials_mark, grpc_rb_credentials_free,
static rb_data_type_t grpc_rb_channel_credentials_data_type = {
"grpc_channel_credentials",
{grpc_rb_channel_credentials_mark, grpc_rb_channel_credentials_free,
GRPC_RB_MEMSIZE_UNAVAILABLE, {NULL, NULL}},
NULL,
NULL,
RUBY_TYPED_FREE_IMMEDIATELY};
/* Allocates Credential instances.
/* Allocates ChannelCredential instances.
Provides safe initial defaults for the instance fields. */
static VALUE grpc_rb_credentials_alloc(VALUE cls) {
grpc_rb_credentials *wrapper = ALLOC(grpc_rb_credentials);
static VALUE grpc_rb_channel_credentials_alloc(VALUE cls) {
grpc_rb_channel_credentials *wrapper = ALLOC(grpc_rb_channel_credentials);
wrapper->wrapped = NULL;
wrapper->mark = Qnil;
return TypedData_Wrap_Struct(cls, &grpc_rb_credentials_data_type, wrapper);
return TypedData_Wrap_Struct(cls, &grpc_rb_channel_credentials_data_type, wrapper);
}
/* Clones Credentials instances.
Gives Credentials a consistent implementation of Ruby's object copy/dup
/* Clones ChannelCredentials instances.
Gives ChannelCredentials a consistent implementation of Ruby's object copy/dup
protocol. */
static VALUE grpc_rb_credentials_init_copy(VALUE copy, VALUE orig) {
grpc_rb_credentials *orig_cred = NULL;
grpc_rb_credentials *copy_cred = NULL;
static VALUE grpc_rb_channel_credentials_init_copy(VALUE copy, VALUE orig) {
grpc_rb_channel_credentials *orig_cred = NULL;
grpc_rb_channel_credentials *copy_cred = NULL;
if (copy == orig) {
return copy;
@ -116,83 +117,22 @@ static VALUE grpc_rb_credentials_init_copy(VALUE copy, VALUE orig) {
/* Raise an error if orig is not a credentials object or a subclass. */
if (TYPE(orig) != T_DATA ||
RDATA(orig)->dfree != (RUBY_DATA_FUNC)grpc_rb_credentials_free) {
rb_raise(rb_eTypeError, "not a %s", rb_obj_classname(grpc_rb_cCredentials));
RDATA(orig)->dfree != (RUBY_DATA_FUNC)grpc_rb_channel_credentials_free) {
rb_raise(rb_eTypeError, "not a %s",
rb_obj_classname(grpc_rb_cChannelCredentials));
}
TypedData_Get_Struct(orig, grpc_rb_credentials,
&grpc_rb_credentials_data_type, orig_cred);
TypedData_Get_Struct(copy, grpc_rb_credentials,
&grpc_rb_credentials_data_type, copy_cred);
TypedData_Get_Struct(orig, grpc_rb_channel_credentials,
&grpc_rb_channel_credentials_data_type, orig_cred);
TypedData_Get_Struct(copy, grpc_rb_channel_credentials,
&grpc_rb_channel_credentials_data_type, copy_cred);
/* use ruby's MEMCPY to make a byte-for-byte copy of the credentials
* wrapper object. */
MEMCPY(copy_cred, orig_cred, grpc_rb_credentials, 1);
MEMCPY(copy_cred, orig_cred, grpc_rb_channel_credentials, 1);
return copy;
}
/*
call-seq:
creds = Credentials.default()
Creates the default credential instances. */
static VALUE grpc_rb_default_credentials_create(VALUE cls) {
grpc_rb_credentials *wrapper = ALLOC(grpc_rb_credentials);
wrapper->wrapped = grpc_google_default_credentials_create();
if (wrapper->wrapped == NULL) {
rb_raise(rb_eRuntimeError,
"could not create default credentials, not sure why");
return Qnil;
}
wrapper->mark = Qnil;
return TypedData_Wrap_Struct(cls, &grpc_rb_credentials_data_type, wrapper);
}
/*
call-seq:
creds = Credentials.compute_engine()
Creates the default credential instances. */
static VALUE grpc_rb_compute_engine_credentials_create(VALUE cls) {
grpc_rb_credentials *wrapper = ALLOC(grpc_rb_credentials);
wrapper->wrapped = grpc_google_compute_engine_credentials_create(NULL);
if (wrapper->wrapped == NULL) {
rb_raise(rb_eRuntimeError,
"could not create composite engine credentials, not sure why");
return Qnil;
}
wrapper->mark = Qnil;
return TypedData_Wrap_Struct(cls, &grpc_rb_credentials_data_type, wrapper);
}
/*
call-seq:
creds1 = ...
creds2 = ...
creds3 = creds1.add(creds2)
Creates the default credential instances. */
static VALUE grpc_rb_composite_credentials_create(VALUE self, VALUE other) {
grpc_rb_credentials *self_wrapper = NULL;
grpc_rb_credentials *other_wrapper = NULL;
grpc_rb_credentials *wrapper = NULL;
TypedData_Get_Struct(self, grpc_rb_credentials,
&grpc_rb_credentials_data_type, self_wrapper);
TypedData_Get_Struct(other, grpc_rb_credentials,
&grpc_rb_credentials_data_type, other_wrapper);
wrapper = ALLOC(grpc_rb_credentials);
wrapper->wrapped = grpc_composite_credentials_create(
self_wrapper->wrapped, other_wrapper->wrapped, NULL);
if (wrapper->wrapped == NULL) {
rb_raise(rb_eRuntimeError,
"could not create composite credentials, not sure why");
return Qnil;
}
wrapper->mark = Qnil;
return TypedData_Wrap_Struct(grpc_rb_cCredentials,
&grpc_rb_credentials_data_type, wrapper);
}
/* The attribute used on the mark object to hold the pem_root_certs. */
static ID id_pem_root_certs;
@ -213,12 +153,12 @@ static ID id_pem_cert_chain;
pem_private_key: (optional) PEM encoding of the client's private key
pem_cert_chain: (optional) PEM encoding of the client's cert chain
Initializes Credential instances. */
static VALUE grpc_rb_credentials_init(int argc, VALUE *argv, VALUE self) {
static VALUE grpc_rb_channel_credentials_init(int argc, VALUE *argv, VALUE self) {
VALUE pem_root_certs = Qnil;
VALUE pem_private_key = Qnil;
VALUE pem_cert_chain = Qnil;
grpc_rb_credentials *wrapper = NULL;
grpc_credentials *creds = NULL;
grpc_rb_channel_credentials *wrapper = NULL;
grpc_channel_credentials *creds = NULL;
grpc_ssl_pem_key_cert_pair key_cert_pair;
MEMZERO(&key_cert_pair, grpc_ssl_pem_key_cert_pair, 1);
/* TODO: Remove mandatory arg when we support default roots. */
@ -226,8 +166,8 @@ static VALUE grpc_rb_credentials_init(int argc, VALUE *argv, VALUE self) {
rb_scan_args(argc, argv, "12", &pem_root_certs, &pem_private_key,
&pem_cert_chain);
TypedData_Get_Struct(self, grpc_rb_credentials,
&grpc_rb_credentials_data_type, wrapper);
TypedData_Get_Struct(self, grpc_rb_channel_credentials,
&grpc_rb_channel_credentials_data_type, wrapper);
if (pem_root_certs == Qnil) {
rb_raise(rb_eRuntimeError,
"could not create a credential: nil pem_root_certs");
@ -256,39 +196,30 @@ static VALUE grpc_rb_credentials_init(int argc, VALUE *argv, VALUE self) {
return self;
}
void Init_grpc_credentials() {
grpc_rb_cCredentials =
rb_define_class_under(grpc_rb_mGrpcCore, "Credentials", rb_cObject);
void Init_grpc_channel_credentials() {
grpc_rb_cChannelCredentials =
rb_define_class_under(grpc_rb_mGrpcCore, "ChannelCredentials", rb_cObject);
/* Allocates an object managed by the ruby runtime */
rb_define_alloc_func(grpc_rb_cCredentials, grpc_rb_credentials_alloc);
rb_define_alloc_func(grpc_rb_cChannelCredentials,
grpc_rb_channel_credentials_alloc);
/* Provides a ruby constructor and support for dup/clone. */
rb_define_method(grpc_rb_cCredentials, "initialize", grpc_rb_credentials_init,
-1);
rb_define_method(grpc_rb_cCredentials, "initialize_copy",
grpc_rb_credentials_init_copy, 1);
/* Provide static funcs that create new special instances. */
rb_define_singleton_method(grpc_rb_cCredentials, "default",
grpc_rb_default_credentials_create, 0);
rb_define_singleton_method(grpc_rb_cCredentials, "compute_engine",
grpc_rb_compute_engine_credentials_create, 0);
/* Provide other methods. */
rb_define_method(grpc_rb_cCredentials, "compose",
grpc_rb_composite_credentials_create, 1);
rb_define_method(grpc_rb_cChannelCredentials, "initialize",
grpc_rb_channel_credentials_init, -1);
rb_define_method(grpc_rb_cChannelCredentials, "initialize_copy",
grpc_rb_channel_credentials_init_copy, 1);
id_pem_cert_chain = rb_intern("__pem_cert_chain");
id_pem_private_key = rb_intern("__pem_private_key");
id_pem_root_certs = rb_intern("__pem_root_certs");
}
/* Gets the wrapped grpc_credentials from the ruby wrapper */
grpc_credentials *grpc_rb_get_wrapped_credentials(VALUE v) {
grpc_rb_credentials *wrapper = NULL;
TypedData_Get_Struct(v, grpc_rb_credentials, &grpc_rb_credentials_data_type,
/* 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;
TypedData_Get_Struct(v, grpc_rb_channel_credentials,
&grpc_rb_channel_credentials_data_type,
wrapper);
return wrapper->wrapped;
}

6
src/ruby/ext/grpc/rb_credentials.h → src/ruby/ext/grpc/rb_channel_credentials.h
Unescape View File

@ -38,10 +38,10 @@
#include <grpc/grpc_security.h>
/* Initializes the ruby Credentials class. */
void Init_grpc_credentials();
/* Initializes the ruby ChannelCredentials class. */
void Init_grpc_channel_credentials();
/* Gets the wrapped credentials from the ruby wrapper */
grpc_credentials* grpc_rb_get_wrapped_credentials(VALUE v);
grpc_channel_credentials* grpc_rb_get_wrapped_channel_credentials(VALUE v);
#endif /* GRPC_RB_CREDENTIALS_H_ */

4
src/ruby/ext/grpc/rb_grpc.c
Unescape View File

@ -42,9 +42,9 @@
#include <grpc/support/time.h>
#include "rb_call.h"
#include "rb_channel.h"
#include "rb_channel_credentials.h"
#include "rb_completion_queue.h"
#include "rb_server.h"
#include "rb_credentials.h"
#include "rb_server_credentials.h"
static VALUE grpc_rb_cTimeVal = Qnil;
@ -300,7 +300,7 @@ void Init_grpc() {
Init_grpc_channel();
Init_grpc_completion_queue();
Init_grpc_call();
Init_grpc_credentials();
Init_grpc_channel_credentials();
Init_grpc_server();
Init_grpc_server_credentials();
Init_grpc_status_codes();

Write Preview
Loading…
Cancel
Save