grpc 1.7.3-x86-linux → 1.8.0-x86-linux

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

@@ -30,16 +30,16 @@
 
 /* Used to allow grpc_completion_queue_next call to release the GIL */
 typedef struct next_call_stack {
-  grpc_completion_queue *cq;
+  grpc_completion_queue* cq;
   grpc_event event;
   gpr_timespec timeout;
-  void *tag;
+  void* tag;
   volatile int interrupted;
 } next_call_stack;
 
 /* Calls grpc_completion_queue_pluck without holding the ruby GIL */
-static void *grpc_rb_completion_queue_pluck_no_gil(void *param) {
-  next_call_stack *const next_call = (next_call_stack *)param;
+static void* grpc_rb_completion_queue_pluck_no_gil(void* param) {
+  next_call_stack* const next_call = (next_call_stack*)param;
   gpr_timespec increment = gpr_time_from_millis(20, GPR_TIMESPAN);
   gpr_timespec deadline;
   do {
@@ -55,7 +55,7 @@ static void *grpc_rb_completion_queue_pluck_no_gil(void *param) {
 }
 
 /* Helper function to free a completion queue. */
-void grpc_rb_completion_queue_destroy(grpc_completion_queue *cq) {
+void grpc_rb_completion_queue_destroy(grpc_completion_queue* cq) {
   /* Every function that adds an event to a queue also synchronously plucks
      that event from the queue, and holds a reference to the Ruby object that
      holds the queue, so we only get to this point if all of those functions
@@ -64,15 +64,15 @@ void grpc_rb_completion_queue_destroy(grpc_completion_queue *cq) {
   grpc_completion_queue_destroy(cq);
 }
 
-static void unblock_func(void *param) {
-  next_call_stack *const next_call = (next_call_stack *)param;
+static void unblock_func(void* param) {
+  next_call_stack* const next_call = (next_call_stack*)param;
   next_call->interrupted = 1;
 }
 
 /* Does the same thing as grpc_completion_queue_pluck, while properly releasing
    the GVL and handling interrupts */
-grpc_event rb_completion_queue_pluck(grpc_completion_queue *queue, void *tag,
-                                     gpr_timespec deadline, void *reserved) {
+grpc_event rb_completion_queue_pluck(grpc_completion_queue* queue, void* tag,
+                                     gpr_timespec deadline, void* reserved) {
   next_call_stack next_call;
   MEMZERO(&next_call, next_call_stack, 1);
   next_call.cq = queue;
@@ -91,8 +91,8 @@ grpc_event rb_completion_queue_pluck(grpc_completion_queue *queue, void *tag,
   do {
     next_call.interrupted = 0;
     rb_thread_call_without_gvl(grpc_rb_completion_queue_pluck_no_gil,
-                               (void *)&next_call, unblock_func,
-                               (void *)&next_call);
+                               (void*)&next_call, unblock_func,
+                               (void*)&next_call);
     /* If an interrupt prevented pluck from returning useful information, then
        any plucks that did complete must have timed out */
   } while (next_call.interrupted && next_call.event.type == GRPC_QUEUE_TIMEOUT);

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

@@ -23,14 +23,14 @@
 
 #include <grpc/grpc.h>
 
-void grpc_rb_completion_queue_destroy(grpc_completion_queue *cq);
+void grpc_rb_completion_queue_destroy(grpc_completion_queue* cq);
 
 /**
  * Makes the implementation of CompletionQueue#pluck available in other files
  *
  * This avoids having code that holds the GIL repeated at multiple sites.
  */
-grpc_event rb_completion_queue_pluck(grpc_completion_queue *queue, void *tag,
-                                     gpr_timespec deadline, void *reserved);
+grpc_event rb_completion_queue_pluck(grpc_completion_queue* queue, void* tag,
+                                     gpr_timespec deadline, void* reserved);
 
 #endif /* GRPC_RB_COMPLETION_QUEUE_H_ */

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

@@ -47,17 +47,17 @@ static VALUE id_compress_level_high = Qnil;
  * Ruby objects and don't have a mark for GC. */
 typedef struct grpc_rb_compression_options {
   /* The actual compression options that's being wrapped */
-  grpc_compression_options *wrapped;
+  grpc_compression_options* wrapped;
 } grpc_rb_compression_options;
 
 /* Destroys the compression options instances and free the
  * wrapped grpc compression options. */
-static void grpc_rb_compression_options_free(void *p) {
-  grpc_rb_compression_options *wrapper = NULL;
+static void grpc_rb_compression_options_free(void* p) {
+  grpc_rb_compression_options* wrapper = NULL;
   if (p == NULL) {
     return;
   };
-  wrapper = (grpc_rb_compression_options *)p;
+  wrapper = (grpc_rb_compression_options*)p;
 
   if (wrapper->wrapped != NULL) {
     gpr_free(wrapper->wrapped);
@@ -85,7 +85,7 @@ static rb_data_type_t grpc_rb_compression_options_data_type = {
    Allocate the wrapped grpc compression options and
    initialize it here too. */
 static VALUE grpc_rb_compression_options_alloc(VALUE cls) {
-  grpc_rb_compression_options *wrapper = NULL;
+  grpc_rb_compression_options* wrapper = NULL;
 
   grpc_ruby_once_init();
 
@@ -103,7 +103,7 @@ static VALUE grpc_rb_compression_options_alloc(VALUE cls) {
 VALUE grpc_rb_compression_options_disable_compression_algorithm_internal(
     VALUE self, VALUE algorithm_to_disable) {
   grpc_compression_algorithm compression_algorithm = 0;
-  grpc_rb_compression_options *wrapper = NULL;
+  grpc_rb_compression_options* wrapper = NULL;
 
   TypedData_Get_Struct(self, grpc_rb_compression_options,
                        &grpc_rb_compression_options_data_type, wrapper);
@@ -145,7 +145,7 @@ grpc_compression_level grpc_rb_compression_options_level_name_to_value_internal(
 /* Sets the default compression level, given the name of a compression level.
  * Throws an error if no algorithm matched. */
 void grpc_rb_compression_options_set_default_level(
-    grpc_compression_options *options, VALUE new_level_name) {
+    grpc_compression_options* options, VALUE new_level_name) {
   options->default_level.level =
       grpc_rb_compression_options_level_name_to_value_internal(new_level_name);
   options->default_level.is_set = 1;
@@ -156,10 +156,10 @@ void grpc_rb_compression_options_set_default_level(
  * algorithm_value is an out parameter.
  * Raises an error if the name of the algorithm passed in is invalid. */
 void grpc_rb_compression_options_algorithm_name_to_value_internal(
-    grpc_compression_algorithm *algorithm_value, VALUE algorithm_name) {
+    grpc_compression_algorithm* algorithm_value, VALUE algorithm_name) {
   grpc_slice name_slice;
   VALUE algorithm_name_as_string = Qnil;
-  char *tmp_str = NULL;
+  char* tmp_str = NULL;
 
   Check_Type(algorithm_name, T_SYMBOL);
 
@@ -186,7 +186,7 @@ void grpc_rb_compression_options_algorithm_name_to_value_internal(
  * readable algorithm name. */
 VALUE grpc_rb_compression_options_is_algorithm_enabled(VALUE self,
                                                        VALUE algorithm_name) {
-  grpc_rb_compression_options *wrapper = NULL;
+  grpc_rb_compression_options* wrapper = NULL;
   grpc_compression_algorithm internal_algorithm_value;
 
   TypedData_Get_Struct(self, grpc_rb_compression_options,
@@ -204,7 +204,7 @@ VALUE grpc_rb_compression_options_is_algorithm_enabled(VALUE self,
 /* Sets the default algorithm to the name of the algorithm passed in.
  * Raises an error if the name is not a valid compression algorithm name. */
 void grpc_rb_compression_options_set_default_algorithm(
-    grpc_compression_options *options, VALUE algorithm_name) {
+    grpc_compression_options* options, VALUE algorithm_name) {
   grpc_rb_compression_options_algorithm_name_to_value_internal(
       &options->default_algorithm.algorithm, algorithm_name);
   options->default_algorithm.is_set = 1;
@@ -214,7 +214,7 @@ void grpc_rb_compression_options_set_default_algorithm(
  * algorithm.
  * Fails if the algorithm name is invalid. */
 void grpc_rb_compression_options_disable_algorithm(
-    grpc_compression_options *compression_options, VALUE algorithm_name) {
+    grpc_compression_options* compression_options, VALUE algorithm_name) {
   grpc_compression_algorithm internal_algorithm_value;
 
   grpc_rb_compression_options_algorithm_name_to_value_internal(
@@ -226,8 +226,8 @@ void grpc_rb_compression_options_disable_algorithm(
 /* Provides a ruby hash of GRPC core channel argument key-values that
  * correspond to the compression settings on this instance. */
 VALUE grpc_rb_compression_options_to_hash(VALUE self) {
-  grpc_rb_compression_options *wrapper = NULL;
-  grpc_compression_options *compression_options = NULL;
+  grpc_rb_compression_options* wrapper = NULL;
+  grpc_compression_options* compression_options = NULL;
   VALUE channel_arg_hash = rb_hash_new();
   VALUE key = Qnil;
   VALUE value = Qnil;
@@ -284,7 +284,7 @@ VALUE grpc_rb_compression_options_level_value_to_name_internal(
  * Fails if the enum value is invalid. */
 VALUE grpc_rb_compression_options_algorithm_value_to_name_internal(
     grpc_compression_algorithm internal_value) {
-  char *algorithm_name = NULL;
+  char* algorithm_name = NULL;
 
   if (!grpc_compression_algorithm_name(internal_value, &algorithm_name)) {
     rb_raise(rb_eArgError, "Failed to convert algorithm value to name");
@@ -297,7 +297,7 @@ VALUE grpc_rb_compression_options_algorithm_value_to_name_internal(
  * Returns nil if no algorithm has been set. */
 VALUE grpc_rb_compression_options_get_default_algorithm(VALUE self) {
   grpc_compression_algorithm internal_value;
-  grpc_rb_compression_options *wrapper = NULL;
+  grpc_rb_compression_options* wrapper = NULL;
 
   TypedData_Get_Struct(self, grpc_rb_compression_options,
                        &grpc_rb_compression_options_data_type, wrapper);
@@ -316,7 +316,7 @@ VALUE grpc_rb_compression_options_get_default_algorithm(VALUE self) {
  * A nil return value means that it hasn't been set. */
 VALUE grpc_rb_compression_options_get_default_level(VALUE self) {
   grpc_compression_level internal_value;
-  grpc_rb_compression_options *wrapper = NULL;
+  grpc_rb_compression_options* wrapper = NULL;
 
   TypedData_Get_Struct(self, grpc_rb_compression_options,
                        &grpc_rb_compression_options_data_type, wrapper);
@@ -335,7 +335,7 @@ VALUE grpc_rb_compression_options_get_default_level(VALUE self) {
 VALUE grpc_rb_compression_options_get_disabled_algorithms(VALUE self) {
   VALUE disabled_algorithms = rb_ary_new();
   grpc_compression_algorithm internal_value;
-  grpc_rb_compression_options *wrapper = NULL;
+  grpc_rb_compression_options* wrapper = NULL;
 
   TypedData_Get_Struct(self, grpc_rb_compression_options,
                        &grpc_rb_compression_options_data_type, wrapper);
@@ -363,8 +363,8 @@ VALUE grpc_rb_compression_options_get_disabled_algorithms(VALUE self) {
  *   channel_arg hash = Hash.new[...]
  *   channel_arg_hash_with_compression_options = channel_arg_hash.merge(options)
  */
-VALUE grpc_rb_compression_options_init(int argc, VALUE *argv, VALUE self) {
-  grpc_rb_compression_options *wrapper = NULL;
+VALUE grpc_rb_compression_options_init(int argc, VALUE* argv, VALUE self) {
+  grpc_rb_compression_options* wrapper = NULL;
   VALUE default_algorithm = Qnil;
   VALUE default_level = Qnil;
   VALUE disabled_algorithms = Qnil;

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

@@ -31,15 +31,15 @@
 
 typedef struct grpc_rb_event {
   // callback will be called with argument while holding the GVL
-  void (*callback)(void *);
-  void *argument;
+  void (*callback)(void*);
+  void* argument;
 
-  struct grpc_rb_event *next;
+  struct grpc_rb_event* next;
 } grpc_rb_event;
 
 typedef struct grpc_rb_event_queue {
-  grpc_rb_event *head;
-  grpc_rb_event *tail;
+  grpc_rb_event* head;
+  grpc_rb_event* tail;
 
   gpr_mu mu;
   gpr_cv cv;
@@ -50,8 +50,8 @@ typedef struct grpc_rb_event_queue {
 
 static grpc_rb_event_queue event_queue;
 
-void grpc_rb_event_queue_enqueue(void (*callback)(void *), void *argument) {
-  grpc_rb_event *event = gpr_malloc(sizeof(grpc_rb_event));
+void grpc_rb_event_queue_enqueue(void (*callback)(void*), void* argument) {
+  grpc_rb_event* event = gpr_malloc(sizeof(grpc_rb_event));
   event->callback = callback;
   event->argument = argument;
   event->next = NULL;
@@ -66,8 +66,8 @@ void grpc_rb_event_queue_enqueue(void (*callback)(void *), void *argument) {
   gpr_mu_unlock(&event_queue.mu);
 }
 
-static grpc_rb_event *grpc_rb_event_queue_dequeue() {
-  grpc_rb_event *event;
+static grpc_rb_event* grpc_rb_event_queue_dequeue() {
+  grpc_rb_event* event;
   if (event_queue.head == NULL) {
     event = NULL;
   } else {
@@ -86,8 +86,8 @@ static void grpc_rb_event_queue_destroy() {
   gpr_cv_destroy(&event_queue.cv);
 }
 
-static void *grpc_rb_wait_for_event_no_gil(void *param) {
-  grpc_rb_event *event = NULL;
+static void* grpc_rb_wait_for_event_no_gil(void* param) {
+  grpc_rb_event* event = NULL;
   (void)param;
   gpr_mu_lock(&event_queue.mu);
   while (!event_queue.abort) {
@@ -102,7 +102,7 @@ static void *grpc_rb_wait_for_event_no_gil(void *param) {
   return NULL;
 }
 
-static void grpc_rb_event_unblocking_func(void *arg) {
+static void grpc_rb_event_unblocking_func(void* arg) {
   (void)arg;
   gpr_mu_lock(&event_queue.mu);
   event_queue.abort = true;
@@ -113,10 +113,10 @@ static void grpc_rb_event_unblocking_func(void *arg) {
 /* This is the implementation of the thread that handles auth metadata plugin
  * events */
 static VALUE grpc_rb_event_thread(VALUE arg) {
-  grpc_rb_event *event;
+  grpc_rb_event* event;
   (void)arg;
   while (true) {
-    event = (grpc_rb_event *)rb_thread_call_without_gvl(
+    event = (grpc_rb_event*)rb_thread_call_without_gvl(
         grpc_rb_wait_for_event_no_gil, NULL, grpc_rb_event_unblocking_func,
         NULL);
     if (event == NULL) {

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

@@ -18,4 +18,4 @@
 
 void grpc_rb_event_queue_thread_start();
 
-void grpc_rb_event_queue_enqueue(void (*callback)(void *), void *argument);
+void grpc_rb_event_queue_enqueue(void (*callback)(void*), void* argument);

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

@@ -90,9 +90,9 @@ static ID id_tv_nsec;
  */
 gpr_timespec grpc_rb_time_timeval(VALUE time, int interval) {
   gpr_timespec t;
-  gpr_timespec *time_const;
-  const char *tstr = interval ? "time interval" : "time";
-  const char *want = " want <secs from epoch>|<Time>|<GRPC::TimeConst.*>";
+  gpr_timespec* time_const;
+  const char* tstr = interval ? "time interval" : "time";
+  const char* want = " want <secs from epoch>|<Time>|<GRPC::TimeConst.*>";
 
   t.clock_type = GPR_CLOCK_REALTIME;
   switch (TYPE(time)) {
@@ -201,7 +201,7 @@ static ID id_to_s;
 
 /* Converts a wrapped time constant to a standard time. */
 static VALUE grpc_rb_time_val_to_time(VALUE self) {
-  gpr_timespec *time_const = NULL;
+  gpr_timespec* time_const = NULL;
   gpr_timespec real_time;
   TypedData_Get_Struct(self, gpr_timespec, &grpc_rb_timespec_data_type,
                        time_const);
@@ -236,15 +236,15 @@ static void Init_grpc_time_consts() {
   rb_define_const(
       grpc_rb_mTimeConsts, "ZERO",
       TypedData_Wrap_Struct(grpc_rb_cTimeVal, &grpc_rb_timespec_data_type,
-                            (void *)&zero_realtime));
+                            (void*)&zero_realtime));
   rb_define_const(
       grpc_rb_mTimeConsts, "INFINITE_FUTURE",
       TypedData_Wrap_Struct(grpc_rb_cTimeVal, &grpc_rb_timespec_data_type,
-                            (void *)&inf_future_realtime));
+                            (void*)&inf_future_realtime));
   rb_define_const(
       grpc_rb_mTimeConsts, "INFINITE_PAST",
       TypedData_Wrap_Struct(grpc_rb_cTimeVal, &grpc_rb_timespec_data_type,
-                            (void *)&inf_past_realtime));
+                            (void*)&inf_past_realtime));
   rb_define_method(grpc_rb_cTimeVal, "to_time", grpc_rb_time_val_to_time, 0);
   rb_define_method(grpc_rb_cTimeVal, "inspect", grpc_rb_time_val_inspect, 0);
   rb_define_method(grpc_rb_cTimeVal, "to_s", grpc_rb_time_val_to_s, 0);
@@ -315,8 +315,8 @@ void Init_grpc_c() {
     return;
   }
 
-  bg_thread_init_rb_mu = rb_mutex_new();
   rb_global_variable(&bg_thread_init_rb_mu);
+  bg_thread_init_rb_mu = rb_mutex_new();
 
   grpc_rb_mGRPC = rb_define_module("GRPC");
   grpc_rb_mGrpcCore = rb_define_module_under(grpc_rb_mGRPC, "Core");

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

@@ -22,34 +22,6 @@
 
 #include "rb_grpc_imports.generated.h"
 
-census_initialize_type census_initialize_import;
-census_shutdown_type census_shutdown_import;
-census_supported_type census_supported_import;
-census_enabled_type census_enabled_import;
-census_context_create_type census_context_create_import;
-census_context_destroy_type census_context_destroy_import;
-census_context_get_status_type census_context_get_status_import;
-census_context_initialize_iterator_type census_context_initialize_iterator_import;
-census_context_next_tag_type census_context_next_tag_import;
-census_context_get_tag_type census_context_get_tag_import;
-census_context_encode_type census_context_encode_import;
-census_context_decode_type census_context_decode_import;
-census_trace_mask_type census_trace_mask_import;
-census_set_trace_mask_type census_set_trace_mask_import;
-census_start_rpc_op_timestamp_type census_start_rpc_op_timestamp_import;
-census_start_client_rpc_op_type census_start_client_rpc_op_import;
-census_set_rpc_client_peer_type census_set_rpc_client_peer_import;
-census_start_server_rpc_op_type census_start_server_rpc_op_import;
-census_start_op_type census_start_op_import;
-census_end_op_type census_end_op_import;
-census_trace_print_type census_trace_print_import;
-census_trace_scan_start_type census_trace_scan_start_import;
-census_get_trace_record_type census_get_trace_record_import;
-census_trace_scan_end_type census_trace_scan_end_import;
-census_define_resource_type census_define_resource_import;
-census_delete_resource_type census_delete_resource_import;
-census_resource_id_type census_resource_id_import;
-census_record_values_type census_record_values_import;
 grpc_compression_algorithm_parse_type grpc_compression_algorithm_parse_import;
 grpc_compression_algorithm_name_type grpc_compression_algorithm_name_import;
 grpc_stream_compression_algorithm_name_type grpc_stream_compression_algorithm_name_import;
@@ -77,6 +49,8 @@ grpc_completion_queue_next_type grpc_completion_queue_next_import;
 grpc_completion_queue_pluck_type grpc_completion_queue_pluck_import;
 grpc_completion_queue_shutdown_type grpc_completion_queue_shutdown_import;
 grpc_completion_queue_destroy_type grpc_completion_queue_destroy_import;
+grpc_completion_queue_thread_local_cache_init_type grpc_completion_queue_thread_local_cache_init_import;
+grpc_completion_queue_thread_local_cache_flush_type grpc_completion_queue_thread_local_cache_flush_import;
 grpc_alarm_create_type grpc_alarm_create_import;
 grpc_alarm_set_type grpc_alarm_set_import;
 grpc_alarm_cancel_type grpc_alarm_cancel_import;
@@ -153,8 +127,14 @@ grpc_google_iam_credentials_create_type grpc_google_iam_credentials_create_impor
 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;
 grpc_ssl_server_credentials_create_ex_type grpc_ssl_server_credentials_create_ex_import;
+grpc_ssl_server_credentials_create_options_using_config_type grpc_ssl_server_credentials_create_options_using_config_import;
+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;
@@ -192,7 +172,6 @@ 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;
-grpc_slice_buf_cmp_type grpc_slice_buf_cmp_import;
 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;
@@ -330,34 +309,6 @@ gpr_sleep_until_type gpr_sleep_until_import;
 gpr_timespec_to_micros_type gpr_timespec_to_micros_import;
 
 void grpc_rb_load_imports(HMODULE library) {
-  census_initialize_import = (census_initialize_type) GetProcAddress(library, "census_initialize");
-  census_shutdown_import = (census_shutdown_type) GetProcAddress(library, "census_shutdown");
-  census_supported_import = (census_supported_type) GetProcAddress(library, "census_supported");
-  census_enabled_import = (census_enabled_type) GetProcAddress(library, "census_enabled");
-  census_context_create_import = (census_context_create_type) GetProcAddress(library, "census_context_create");
-  census_context_destroy_import = (census_context_destroy_type) GetProcAddress(library, "census_context_destroy");
-  census_context_get_status_import = (census_context_get_status_type) GetProcAddress(library, "census_context_get_status");
-  census_context_initialize_iterator_import = (census_context_initialize_iterator_type) GetProcAddress(library, "census_context_initialize_iterator");
-  census_context_next_tag_import = (census_context_next_tag_type) GetProcAddress(library, "census_context_next_tag");
-  census_context_get_tag_import = (census_context_get_tag_type) GetProcAddress(library, "census_context_get_tag");
-  census_context_encode_import = (census_context_encode_type) GetProcAddress(library, "census_context_encode");
-  census_context_decode_import = (census_context_decode_type) GetProcAddress(library, "census_context_decode");
-  census_trace_mask_import = (census_trace_mask_type) GetProcAddress(library, "census_trace_mask");
-  census_set_trace_mask_import = (census_set_trace_mask_type) GetProcAddress(library, "census_set_trace_mask");
-  census_start_rpc_op_timestamp_import = (census_start_rpc_op_timestamp_type) GetProcAddress(library, "census_start_rpc_op_timestamp");
-  census_start_client_rpc_op_import = (census_start_client_rpc_op_type) GetProcAddress(library, "census_start_client_rpc_op");
-  census_set_rpc_client_peer_import = (census_set_rpc_client_peer_type) GetProcAddress(library, "census_set_rpc_client_peer");
-  census_start_server_rpc_op_import = (census_start_server_rpc_op_type) GetProcAddress(library, "census_start_server_rpc_op");
-  census_start_op_import = (census_start_op_type) GetProcAddress(library, "census_start_op");
-  census_end_op_import = (census_end_op_type) GetProcAddress(library, "census_end_op");
-  census_trace_print_import = (census_trace_print_type) GetProcAddress(library, "census_trace_print");
-  census_trace_scan_start_import = (census_trace_scan_start_type) GetProcAddress(library, "census_trace_scan_start");
-  census_get_trace_record_import = (census_get_trace_record_type) GetProcAddress(library, "census_get_trace_record");
-  census_trace_scan_end_import = (census_trace_scan_end_type) GetProcAddress(library, "census_trace_scan_end");
-  census_define_resource_import = (census_define_resource_type) GetProcAddress(library, "census_define_resource");
-  census_delete_resource_import = (census_delete_resource_type) GetProcAddress(library, "census_delete_resource");
-  census_resource_id_import = (census_resource_id_type) GetProcAddress(library, "census_resource_id");
-  census_record_values_import = (census_record_values_type) GetProcAddress(library, "census_record_values");
   grpc_compression_algorithm_parse_import = (grpc_compression_algorithm_parse_type) GetProcAddress(library, "grpc_compression_algorithm_parse");
   grpc_compression_algorithm_name_import = (grpc_compression_algorithm_name_type) GetProcAddress(library, "grpc_compression_algorithm_name");
   grpc_stream_compression_algorithm_name_import = (grpc_stream_compression_algorithm_name_type) GetProcAddress(library, "grpc_stream_compression_algorithm_name");
@@ -385,6 +336,8 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_completion_queue_pluck_import = (grpc_completion_queue_pluck_type) GetProcAddress(library, "grpc_completion_queue_pluck");
   grpc_completion_queue_shutdown_import = (grpc_completion_queue_shutdown_type) GetProcAddress(library, "grpc_completion_queue_shutdown");
   grpc_completion_queue_destroy_import = (grpc_completion_queue_destroy_type) GetProcAddress(library, "grpc_completion_queue_destroy");
+  grpc_completion_queue_thread_local_cache_init_import = (grpc_completion_queue_thread_local_cache_init_type) GetProcAddress(library, "grpc_completion_queue_thread_local_cache_init");
+  grpc_completion_queue_thread_local_cache_flush_import = (grpc_completion_queue_thread_local_cache_flush_type) GetProcAddress(library, "grpc_completion_queue_thread_local_cache_flush");
   grpc_alarm_create_import = (grpc_alarm_create_type) GetProcAddress(library, "grpc_alarm_create");
   grpc_alarm_set_import = (grpc_alarm_set_type) GetProcAddress(library, "grpc_alarm_set");
   grpc_alarm_cancel_import = (grpc_alarm_cancel_type) GetProcAddress(library, "grpc_alarm_cancel");
@@ -461,8 +414,14 @@ void grpc_rb_load_imports(HMODULE library) {
   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");
   grpc_ssl_server_credentials_create_ex_import = (grpc_ssl_server_credentials_create_ex_type) GetProcAddress(library, "grpc_ssl_server_credentials_create_ex");
+  grpc_ssl_server_credentials_create_options_using_config_import = (grpc_ssl_server_credentials_create_options_using_config_type) GetProcAddress(library, "grpc_ssl_server_credentials_create_options_using_config");
+  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");
@@ -500,7 +459,6 @@ void grpc_rb_load_imports(HMODULE library) {
   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");
-  grpc_slice_buf_cmp_import = (grpc_slice_buf_cmp_type) GetProcAddress(library, "grpc_slice_buf_cmp");
   grpc_slice_buf_start_eq_import = (grpc_slice_buf_start_eq_type) GetProcAddress(library, "grpc_slice_buf_start_eq");
   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");