grpc 1.36.0-x64-mingw32 → 1.37.0.pre1-x64-mingw32

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_ */

data/src/ruby/lib/grpc/generic/client_stub.rb

@@ -41,8 +41,10 @@ module GRPC
         channel_args['grpc.primary_user_agent'] += ' '
       end
       channel_args['grpc.primary_user_agent'] += "grpc-ruby/#{VERSION}"
-      unless creds.is_a?(Core::ChannelCredentials) || creds.is_a?(Symbol)
-        fail(TypeError, '!ChannelCredentials or Symbol')
+      unless creds.is_a?(Core::ChannelCredentials) ||
+             creds.is_a?(Core::XdsChannelCredentials) ||
+             creds.is_a?(Symbol)
+        fail(TypeError, 'creds is not a ChannelCredentials, XdsChannelCredentials, or Symbol')
       end
       Core::Channel.new(host, channel_args, creds)
     end

data/src/ruby/lib/grpc/version.rb

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.36.0'
+  VERSION = '1.37.0.pre1'
 end

data/src/ruby/pb/test/xds_client.rb

@@ -40,15 +40,11 @@ require_relative '../src/proto/grpc/testing/messages_pb'
 require_relative '../src/proto/grpc/testing/test_services_pb'
 
 class RpcConfig
-  def init(rpcs_to_send, metadata_to_send)
+  attr_reader :rpcs_to_send, :metadata_to_send, :timeout_sec
+  def init(rpcs_to_send, metadata_to_send, timeout_sec = 0)
     @rpcs_to_send = rpcs_to_send
     @metadata_to_send = metadata_to_send
-  end
-  def rpcs_to_send
-    @rpcs_to_send
-  end
-  def metadata_to_send
-    @metadata_to_send
+    @timeout_sec = timeout_sec
   end
 end
 
@@ -71,6 +67,7 @@ $accumulated_stats_mu = Mutex.new
 $num_rpcs_started_by_method = {}
 $num_rpcs_succeeded_by_method = {}
 $num_rpcs_failed_by_method = {}
+$accumulated_method_stats = {}
 
 # RubyLogger defines a logger for gRPC based on the standard ruby logger.
 module RubyLogger
@@ -98,13 +95,26 @@ def create_stub(opts)
   )
 end
 
+class StatsPerMethod
+  attr_reader :rpcs_started, :result
+  def initialize()
+    @rpcs_started = 0
+    @result = Hash.new(0)
+  end
+  def increment_rpcs_started()
+    @rpcs_started += 1
+  end
+  def add_result(status_code)
+    @result[status_code] += 1
+  end
+end
+
 class ConfigureTarget < Grpc::Testing::XdsUpdateClientConfigureService::Service
   include Grpc::Testing
 
   def configure(req, _call)
-    rpcs_to_send = req['types'];
     metadata_to_send = {}
-    req['metadata'].each do |m|
+    req.metadata.each do |m|
       rpc = m.type
       if !metadata_to_send.key?(rpc)
         metadata_to_send[rpc] = {}
@@ -113,13 +123,10 @@ class ConfigureTarget < Grpc::Testing::XdsUpdateClientConfigureService::Service
       metadata_value = m.value
       metadata_to_send[rpc][metadata_key] = metadata_value
     end
-    GRPC.logger.info("Configuring new rpcs_to_send and metadata_to_send...")
-    GRPC.logger.info(rpcs_to_send)
-    GRPC.logger.info(metadata_to_send)
     new_rpc_config = RpcConfig.new
-    new_rpc_config.init(rpcs_to_send, metadata_to_send)
+    new_rpc_config.init(req['types'], metadata_to_send, req['timeout_sec'])
     $rpc_config = new_rpc_config
-    ClientConfigureResponse.new();
+    ClientConfigureResponse.new()
   end
 end
 
@@ -159,15 +166,23 @@ class TestTarget < Grpc::Testing::LoadBalancerStatsService::Service
       rpcs_by_method: rpcs_by_method,
       rpcs_by_peer: watcher['rpcs_by_peer'],
       num_failures: watcher['no_remote_peer'] + watcher['rpcs_needed']
-    );
+    )
   end
 
   def get_client_accumulated_stats(req, _call)
     $accumulated_stats_mu.synchronize do
+      all_stats_per_method = $accumulated_method_stats.map { |rpc, stats_per_method|
+        [rpc,
+         LoadBalancerAccumulatedStatsResponse::MethodStats.new(
+          rpcs_started: stats_per_method.rpcs_started,
+          result: stats_per_method.result
+         )]
+      }.to_h
       LoadBalancerAccumulatedStatsResponse.new(
         num_rpcs_started_by_method: $num_rpcs_started_by_method,
         num_rpcs_succeeded_by_method: $num_rpcs_succeeded_by_method,
-        num_rpcs_failed_by_method: $num_rpcs_failed_by_method
+        num_rpcs_failed_by_method: $num_rpcs_failed_by_method,
+        stats_per_method: all_stats_per_method,
       )
     end
   end
@@ -176,6 +191,7 @@ end
 # execute 1 RPC and return remote hostname
 def execute_rpc(op, fail_on_failed_rpcs, rpc_stats_key)
   remote_peer = ""
+  status_code = 0
   begin
     op.execute
     if op.metadata.key?('hostname')
@@ -185,8 +201,10 @@ def execute_rpc(op, fail_on_failed_rpcs, rpc_stats_key)
     if fail_on_failed_rpcs
       raise e
     end
+    status_code = e.code
   end
   $accumulated_stats_mu.synchronize do
+    $accumulated_method_stats[rpc_stats_key].add_result(status_code)
     if remote_peer.empty?
       $num_rpcs_failed_by_method[rpc_stats_key] += 1
     else
@@ -207,6 +225,7 @@ def execute_rpc_in_thread(op, rpc_stats_key)
       # Doing this for consistency
       $accumulated_stats_mu.synchronize do
         $num_rpcs_succeeded_by_method[rpc_stats_key] += 1
+        $accumulated_method_stats[rpc_stats_key].add_result(0)
       end
     rescue GRPC::BadStatus => e
       # Normal execution arrives here,
@@ -214,6 +233,7 @@ def execute_rpc_in_thread(op, rpc_stats_key)
       # balancing policy"
       $accumulated_stats_mu.synchronize do
         $num_rpcs_failed_by_method[rpc_stats_key] += 1
+        $accumulated_method_stats[rpc_stats_key].add_result(e.code)
       end
     end
   }
@@ -238,7 +258,8 @@ def run_test_loop(stub, target_seconds_between_rpcs, fail_on_failed_rpcs)
       target_next_start += target_seconds_between_rpcs
       sleep(sleep_seconds)
     end
-    deadline = GRPC::Core::TimeConsts::from_relative_time(30) # 30 seconds
+    deadline_sec = $rpc_config.timeout_sec > 0 ? $rpc_config.timeout_sec : 30
+    deadline = GRPC::Core::TimeConsts::from_relative_time(deadline_sec)
     results = {}
     $rpc_config.rpcs_to_send.each do |rpc|
       # rpc is in the form of :UNARY_CALL or :EMPTY_CALL here
@@ -246,10 +267,7 @@ def run_test_loop(stub, target_seconds_between_rpcs, fail_on_failed_rpcs)
                    $rpc_config.metadata_to_send[rpc] : {}
       $accumulated_stats_mu.synchronize do
         $num_rpcs_started_by_method[rpc.to_s] += 1
-        num_started = $num_rpcs_started_by_method[rpc.to_s]
-        if num_started % 100 == 0
-          GRPC.logger.info("Started #{num_started} of #{rpc}")
-        end
+        $accumulated_method_stats[rpc.to_s].increment_rpcs_started()
       end
       if rpc == :UNARY_CALL
         op = stub.unary_call(simple_req,
@@ -266,11 +284,8 @@ def run_test_loop(stub, target_seconds_between_rpcs, fail_on_failed_rpcs)
       end
       rpc_stats_key = rpc.to_s
       if metadata.key?('rpc-behavior') and
-        (metadata['rpc-behavior'] == 'keep-open')
-        num_open_threads = keep_open_threads.size
-        if num_open_threads % 50 == 0
-          GRPC.logger.info("number of keep_open_threads = #{num_open_threads}")
-        end
+        ((metadata['rpc-behavior'] == 'keep-open') or
+         (metadata['rpc-behavior'].start_with?('sleep')))
         keep_open_threads << execute_rpc_in_thread(op, rpc_stats_key)
       else
         results[rpc] = execute_rpc(op, fail_on_failed_rpcs, rpc_stats_key)
@@ -364,6 +379,7 @@ def main
     $num_rpcs_started_by_method[rpc.to_s] = 0
     $num_rpcs_succeeded_by_method[rpc.to_s] = 0
     $num_rpcs_failed_by_method[rpc.to_s] = 0
+    $accumulated_method_stats[rpc.to_s] = StatsPerMethod.new
   end
 
   # The client just sends rpcs continuously in a regular interval