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

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.33.0.pre1'
+  VERSION = '1.37.0.pre1'
 end

data/src/ruby/pb/src/proto/grpc/testing/messages_pb.rb

@@ -76,6 +76,34 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     add_message "grpc.testing.LoadBalancerStatsResponse.RpcsByPeer" do
       map :rpcs_by_peer, :string, :int32, 1
     end
+    add_message "grpc.testing.LoadBalancerAccumulatedStatsRequest" do
+    end
+    add_message "grpc.testing.LoadBalancerAccumulatedStatsResponse" do
+      map :num_rpcs_started_by_method, :string, :int32, 1
+      map :num_rpcs_succeeded_by_method, :string, :int32, 2
+      map :num_rpcs_failed_by_method, :string, :int32, 3
+      map :stats_per_method, :string, :message, 4, "grpc.testing.LoadBalancerAccumulatedStatsResponse.MethodStats"
+    end
+    add_message "grpc.testing.LoadBalancerAccumulatedStatsResponse.MethodStats" do
+      optional :rpcs_started, :int32, 1
+      map :result, :int32, :int32, 2
+    end
+    add_message "grpc.testing.ClientConfigureRequest" do
+      repeated :types, :enum, 1, "grpc.testing.ClientConfigureRequest.RpcType"
+      repeated :metadata, :message, 2, "grpc.testing.ClientConfigureRequest.Metadata"
+      optional :timeout_sec, :int32, 3
+    end
+    add_message "grpc.testing.ClientConfigureRequest.Metadata" do
+      optional :type, :enum, 1, "grpc.testing.ClientConfigureRequest.RpcType"
+      optional :key, :string, 2
+      optional :value, :string, 3
+    end
+    add_enum "grpc.testing.ClientConfigureRequest.RpcType" do
+      value :EMPTY_CALL, 0
+      value :UNARY_CALL, 1
+    end
+    add_message "grpc.testing.ClientConfigureResponse" do
+    end
     add_enum "grpc.testing.PayloadType" do
       value :COMPRESSABLE, 0
     end
@@ -104,6 +132,13 @@ module Grpc
     LoadBalancerStatsRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.LoadBalancerStatsRequest").msgclass
     LoadBalancerStatsResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.LoadBalancerStatsResponse").msgclass
     LoadBalancerStatsResponse::RpcsByPeer = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.LoadBalancerStatsResponse.RpcsByPeer").msgclass
+    LoadBalancerAccumulatedStatsRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.LoadBalancerAccumulatedStatsRequest").msgclass
+    LoadBalancerAccumulatedStatsResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.LoadBalancerAccumulatedStatsResponse").msgclass
+    LoadBalancerAccumulatedStatsResponse::MethodStats = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.LoadBalancerAccumulatedStatsResponse.MethodStats").msgclass
+    ClientConfigureRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.ClientConfigureRequest").msgclass
+    ClientConfigureRequest::Metadata = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.ClientConfigureRequest.Metadata").msgclass
+    ClientConfigureRequest::RpcType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.ClientConfigureRequest.RpcType").enummodule
+    ClientConfigureResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.ClientConfigureResponse").msgclass
     PayloadType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.PayloadType").enummodule
     GrpclbRouteType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.GrpclbRouteType").enummodule
   end

data/src/ruby/pb/src/proto/grpc/testing/test_services_pb.rb

@@ -110,6 +110,8 @@ module Grpc
 
         # Gets the backend distribution for RPCs sent by a test client.
         rpc :GetClientStats, ::Grpc::Testing::LoadBalancerStatsRequest, ::Grpc::Testing::LoadBalancerStatsResponse
+        # Gets the accumulated stats for RPCs sent by a test client.
+        rpc :GetClientAccumulatedStats, ::Grpc::Testing::LoadBalancerAccumulatedStatsRequest, ::Grpc::Testing::LoadBalancerAccumulatedStatsResponse
       end
 
       Stub = Service.rpc_stub_class
@@ -128,6 +130,22 @@ module Grpc
         rpc :SetNotServing, ::Grpc::Testing::Empty, ::Grpc::Testing::Empty
       end
 
+      Stub = Service.rpc_stub_class
+    end
+    module XdsUpdateClientConfigureService
+      # A service to dynamically update the configuration of an xDS test client.
+      class Service
+
+        include GRPC::GenericService
+
+        self.marshal_class_method = :encode
+        self.unmarshal_class_method = :decode
+        self.service_name = 'grpc.testing.XdsUpdateClientConfigureService'
+
+        # Update the tes client's configuration.
+        rpc :Configure, ::Grpc::Testing::ClientConfigureRequest, ::Grpc::Testing::ClientConfigureResponse
+      end
+
       Stub = Service.rpc_stub_class
     end
   end

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

@@ -39,11 +39,35 @@ require_relative '../src/proto/grpc/testing/empty_pb'
 require_relative '../src/proto/grpc/testing/messages_pb'
 require_relative '../src/proto/grpc/testing/test_services_pb'
 
+class RpcConfig
+  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
+    @timeout_sec = timeout_sec
+  end
+end
+
+# Some global constant mappings
+$RPC_MAP = {
+  'UnaryCall' => :UNARY_CALL,
+  'EmptyCall' => :EMPTY_CALL,
+}
+
 # Some global variables to be shared by server and client
 $watchers = Array.new
 $watchers_mutex = Mutex.new
 $watchers_cv = ConditionVariable.new
 $shutdown = false
+# These can be configured by the test runner dynamically
+$rpc_config = RpcConfig.new
+$rpc_config.init([:UNARY_CALL], {})
+# These stats are shared across threads
+$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
@@ -71,6 +95,41 @@ 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)
+    metadata_to_send = {}
+    req.metadata.each do |m|
+      rpc = m.type
+      if !metadata_to_send.key?(rpc)
+        metadata_to_send[rpc] = {}
+      end
+      metadata_key = m.key
+      metadata_value = m.value
+      metadata_to_send[rpc][metadata_key] = metadata_value
+    end
+    new_rpc_config = RpcConfig.new
+    new_rpc_config.init(req['types'], metadata_to_send, req['timeout_sec'])
+    $rpc_config = new_rpc_config
+    ClientConfigureResponse.new()
+  end
+end
+
 # This implements LoadBalancerStatsService required by the test runner
 class TestTarget < Grpc::Testing::LoadBalancerStatsService::Service
   include Grpc::Testing
@@ -107,73 +166,139 @@ 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,
+        stats_per_method: all_stats_per_method,
+      )
+    end
   end
 end
 
 # execute 1 RPC and return remote hostname
-def execute_rpc(op, fail_on_failed_rpcs)
+def execute_rpc(op, fail_on_failed_rpcs, rpc_stats_key)
   remote_peer = ""
+  status_code = 0
   begin
     op.execute
     if op.metadata.key?('hostname')
       remote_peer = op.metadata['hostname']
     end
   rescue GRPC::BadStatus => e
-    GRPC.logger.info("ruby xds: rpc failed:|#{e.message}|, " \
-                     "this may or may not be expected")
     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
+      $num_rpcs_succeeded_by_method[rpc_stats_key] += 1
+    end
   end
   remote_peer
 end
 
+def execute_rpc_in_thread(op, rpc_stats_key)
+  Thread.new {
+    begin
+      op.execute
+      # The following should _not_ happen with the current spec
+      # because we are only executing RPCs in a thread if we expect it
+      # to be kept open, or deadline_exceeded, or dropped by the load
+      # balancing policy. These RPCs should not complete successfully.
+      # 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,
+      # either because of deadline_exceeded or "call dropped by load
+      # 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
+  }
+end
+
 # send 1 rpc every 1/qps second
-def run_test_loop(stub, target_seconds_between_rpcs, fail_on_failed_rpcs,
-                  rpcs_to_send, metadata_to_send)
+def run_test_loop(stub, target_seconds_between_rpcs, fail_on_failed_rpcs)
   include Grpc::Testing
   simple_req = SimpleRequest.new()
   empty_req = Empty.new()
   target_next_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  # Some RPCs are meant to be "kept open". Since Ruby does not have an
+  # async API, we are executing those RPCs in a thread so that they don't
+  # block.
+  keep_open_threads = Array.new
   while !$shutdown
     now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     sleep_seconds = target_next_start - now
     if sleep_seconds < 0
       target_next_start = now + target_seconds_between_rpcs
-      GRPC.logger.info(
-        "ruby xds: warning, rpc takes too long to finish. " \
-        "Deficit = %.1fms. " \
-        "If you consistently see this, the qps is too high." \
-        % [(sleep_seconds * 1000).abs().round(1)])
     else
       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 = {}
-    rpcs_to_send.each do |rpc|
-      metadata = metadata_to_send.key?(rpc) ? metadata_to_send[rpc] : {}
-      if rpc == 'UnaryCall'
+    $rpc_config.rpcs_to_send.each do |rpc|
+      # rpc is in the form of :UNARY_CALL or :EMPTY_CALL here
+      metadata = $rpc_config.metadata_to_send.key?(rpc) ?
+                   $rpc_config.metadata_to_send[rpc] : {}
+      $accumulated_stats_mu.synchronize do
+        $num_rpcs_started_by_method[rpc.to_s] += 1
+        $accumulated_method_stats[rpc.to_s].increment_rpcs_started()
+      end
+      if rpc == :UNARY_CALL
         op = stub.unary_call(simple_req,
                              metadata: metadata,
                              deadline: deadline,
                              return_op: true)
-      elsif rpc == 'EmptyCall'
+      elsif rpc == :EMPTY_CALL
         op = stub.empty_call(empty_req,
                              metadata: metadata,
                              deadline: deadline,
                              return_op: true)
       else
-        raise "Unsupported rpc %s" % [rpc]
+        raise "Unsupported rpc #{rpc}"
+      end
+      rpc_stats_key = rpc.to_s
+      if metadata.key?('rpc-behavior') and
+        ((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)
       end
-      results[rpc] = execute_rpc(op, fail_on_failed_rpcs)
     end
     $watchers_mutex.synchronize do
       $watchers.each do |watcher|
         # this is counted once when each group of all rpcs_to_send were done
         watcher['rpcs_needed'] -= 1
         results.each do |rpc_name, remote_peer|
+          # These stats expect rpc_name to be in the form of
+          # UnaryCall or EmptyCall, not the underscore-case all-caps form
+          rpc_name = $RPC_MAP.invert()[rpc_name]
           if remote_peer.strip.empty?
             # error is counted per individual RPC
             watcher['no_remote_peer'] += 1
@@ -191,6 +316,7 @@ def run_test_loop(stub, target_seconds_between_rpcs, fail_on_failed_rpcs,
       $watchers_cv.broadcast
     end
   end
+  keep_open_threads.each { |thd| thd.join }
 end
 
 # Args is used to hold the command line info.
@@ -242,18 +368,23 @@ def main
   s = GRPC::RpcServer.new
   s.add_http2_port(host, :this_port_is_insecure)
   s.handle(TestTarget)
+  s.handle(ConfigureTarget)
   server_thread = Thread.new {
     # run the server until the main test runner terminates this process
     s.run_till_terminated_or_interrupted(['TERM'])
   }
 
-  # The client just sends unary rpcs continuously in a regular interval
+  # Initialize stats
+  $RPC_MAP.values.each do |rpc|
+    $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
   stub = create_stub(opts)
   target_seconds_between_rpcs = (1.0 / opts['qps'].to_f)
-  rpcs_to_send = []
-  if opts['rpc']
-    rpcs_to_send = opts['rpc'].split(',')
-  end
   # Convert 'metadata' input in the form of
   #   rpc1:k1:v1,rpc2:k2:v2,rpc1:k3:v3
   # into
@@ -266,11 +397,13 @@ def main
   #       'k2' => 'v2'
   #     },
   #   }
+  rpcs_to_send = []
   metadata_to_send = {}
   if opts['metadata']
     metadata_entries = opts['metadata'].split(',')
     metadata_entries.each do |e|
       (rpc_name, metadata_key, metadata_value) = e.split(':')
+      rpc_name = $RPC_MAP[rpc_name]
       # initialize if we haven't seen this rpc_name yet
       if !metadata_to_send.key?(rpc_name)
         metadata_to_send[rpc_name] = {}
@@ -278,12 +411,20 @@ def main
       metadata_to_send[rpc_name][metadata_key] = metadata_value
     end
   end
+  if opts['rpc']
+    rpcs_to_send = opts['rpc'].split(',')
+  end
+  if rpcs_to_send.size > 0
+    rpcs_to_send.map! { |rpc| $RPC_MAP[rpc] }
+    new_rpc_config = RpcConfig.new
+    new_rpc_config.init(rpcs_to_send, metadata_to_send)
+    $rpc_config = new_rpc_config
+  end
   client_threads = Array.new
   opts['num_channels'].times {
     client_threads << Thread.new {
       run_test_loop(stub, target_seconds_between_rpcs,
-                    opts['fail_on_failed_rpcs'],
-                    rpcs_to_send, metadata_to_send)
+                    opts['fail_on_failed_rpcs'])
     }
   }