grpc 1.28.0.pre1-x86-mingw32 → 1.30.1-x86-mingw32

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

@@ -31,6 +31,7 @@ module GRPC
     #
     # @param s [String] the string to be converted.
     def self.underscore(s)
+      s = +s # Avoid mutating the argument, as it might be frozen.
       s.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
       s.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
       s.tr!('-', '_')
@@ -167,22 +168,22 @@ module GRPC
             if desc.request_response?
               define_method(mth_name) do |req, metadata = {}|
                 GRPC.logger.debug("calling #{@host}:#{route}")
-                request_response(route, req, marshal, unmarshal, metadata)
+                request_response(route, req, marshal, unmarshal, **metadata)
               end
             elsif desc.client_streamer?
               define_method(mth_name) do |reqs, metadata = {}|
                 GRPC.logger.debug("calling #{@host}:#{route}")
-                client_streamer(route, reqs, marshal, unmarshal, metadata)
+                client_streamer(route, reqs, marshal, unmarshal, **metadata)
               end
             elsif desc.server_streamer?
               define_method(mth_name) do |req, metadata = {}, &blk|
                 GRPC.logger.debug("calling #{@host}:#{route}")
-                server_streamer(route, req, marshal, unmarshal, metadata, &blk)
+                server_streamer(route, req, marshal, unmarshal, **metadata, &blk)
               end
             else  # is a bidi_stream
               define_method(mth_name) do |reqs, metadata = {}, &blk|
                 GRPC.logger.debug("calling #{@host}:#{route}")
-                bidi_streamer(route, reqs, marshal, unmarshal, metadata, &blk)
+                bidi_streamer(route, reqs, marshal, unmarshal, **metadata, &blk)
               end
             end
           end

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

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-Struct.new('Status', :code, :details, :metadata)
+Struct.new('Status', :code, :details, :metadata, :debug_error_string)

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

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

data/src/ruby/pb/generate_proto_ruby.sh

@@ -14,11 +14,13 @@
 # limitations under the License.
 
 # Regenerates gRPC service stubs from proto files.
-set +e
+set -e
 cd $(dirname $0)/../../..
 
-PROTOC=bins/opt/protobuf/protoc
-PLUGIN=protoc-gen-grpc=bins/opt/grpc_ruby_plugin
+# protoc and grpc_*_plugin binaries can be obtained by running
+# $ bazel build @com_google_protobuf//:protoc //src/compiler:all
+PROTOC=bazel-bin/external/com_google_protobuf/protoc
+PLUGIN=protoc-gen-grpc=bazel-bin/src/compiler/grpc_ruby_plugin
 
 $PROTOC -I src/proto src/proto/grpc/health/v1/health.proto \
     --grpc_out=src/ruby/pb \

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

@@ -34,6 +34,7 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :oauth_scope, :string, 3
       optional :server_id, :string, 4
       optional :grpclb_route_type, :enum, 5, "grpc.testing.GrpclbRouteType"
+      optional :hostname, :string, 6
     end
     add_message "grpc.testing.StreamingInputCallRequest" do
       optional :payload, :message, 1, "grpc.testing.Payload"
@@ -63,6 +64,14 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :passed, :bool, 1
       repeated :backoff_ms, :int32, 2
     end
+    add_message "grpc.testing.LoadBalancerStatsRequest" do
+      optional :num_rpcs, :int32, 1
+      optional :timeout_sec, :int32, 2
+    end
+    add_message "grpc.testing.LoadBalancerStatsResponse" do
+      map :rpcs_by_peer, :string, :int32, 1
+      optional :num_failures, :int32, 2
+    end
     add_enum "grpc.testing.PayloadType" do
       value :COMPRESSABLE, 0
     end
@@ -88,6 +97,8 @@ module Grpc
     StreamingOutputCallResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.StreamingOutputCallResponse").msgclass
     ReconnectParams = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.ReconnectParams").msgclass
     ReconnectInfo = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.ReconnectInfo").msgclass
+    LoadBalancerStatsRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.LoadBalancerStatsRequest").msgclass
+    LoadBalancerStatsResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.LoadBalancerStatsResponse").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

@@ -96,6 +96,22 @@ module Grpc
         rpc :Stop, Empty, ReconnectInfo
       end
 
+      Stub = Service.rpc_stub_class
+    end
+    module LoadBalancerStatsService
+      # A service used to obtain stats for verifying LB behavior.
+      class Service
+
+        include GRPC::GenericService
+
+        self.marshal_class_method = :encode
+        self.unmarshal_class_method = :decode
+        self.service_name = 'grpc.testing.LoadBalancerStatsService'
+
+        # Gets the backend distribution for RPCs sent by a test client.
+        rpc :GetClientStats, LoadBalancerStatsRequest, LoadBalancerStatsResponse
+      end
+
       Stub = Service.rpc_stub_class
     end
   end

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

@@ -0,0 +1,213 @@
+#!/usr/bin/env ruby
+
+# Copyright 2015 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.
+
+# This is the xDS interop test Ruby client. This is meant to be run by
+# the run_xds_tests.py test runner.
+#
+# Usage: $ tools/run_tests/run_xds_tests.py --test_case=... ...
+#    --client_cmd="path/to/xds_client.rb --server=<hostname> \
+#                                        --stats_port=<port> \
+#                                        --qps=<qps>"
+
+# These lines are required for the generated files to load grpc
+this_dir = File.expand_path(File.dirname(__FILE__))
+lib_dir = File.join(File.dirname(File.dirname(this_dir)), 'lib')
+pb_dir = File.dirname(this_dir)
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+$LOAD_PATH.unshift(pb_dir) unless $LOAD_PATH.include?(pb_dir)
+
+require 'optparse'
+require 'logger'
+
+require_relative '../../lib/grpc'
+require 'google/protobuf'
+
+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'
+
+# Some global variables to be shared by server and client
+$watchers = Array.new
+$watchers_mutex = Mutex.new
+$watchers_cv = ConditionVariable.new
+$shutdown = false
+
+# RubyLogger defines a logger for gRPC based on the standard ruby logger.
+module RubyLogger
+  def logger
+    LOGGER
+  end
+
+  LOGGER = Logger.new(STDOUT)
+  LOGGER.level = Logger::INFO
+end
+
+# GRPC is the general RPC module
+module GRPC
+  # Inject the noop #logger if no module-level logger method has been injected.
+  extend RubyLogger
+end
+
+# creates a test stub
+def create_stub(opts)
+  address = "#{opts.server}"
+  GRPC.logger.info("... connecting insecurely to #{address}")
+  Grpc::Testing::TestService::Stub.new(
+    address,
+    :this_channel_is_insecure,
+  )
+end
+
+# This implements LoadBalancerStatsService required by the test runner
+class TestTarget < Grpc::Testing::LoadBalancerStatsService::Service
+  include Grpc::Testing
+
+  def get_client_stats(req, _call)
+    finish_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) +
+                  req['timeout_sec']
+    watcher = {}
+    $watchers_mutex.synchronize do
+      watcher = {
+        "rpcs_by_peer" => Hash.new(0),
+        "rpcs_needed" => req['num_rpcs'],
+        "no_remote_peer" => 0
+      }
+      $watchers << watcher
+      seconds_remaining = finish_time -
+                          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      while watcher['rpcs_needed'] > 0 && seconds_remaining > 0
+        $watchers_cv.wait($watchers_mutex, seconds_remaining)
+        seconds_remaining = finish_time -
+                            Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+      $watchers.delete_at($watchers.index(watcher))
+    end
+    LoadBalancerStatsResponse.new(
+      rpcs_by_peer: watcher['rpcs_by_peer'],
+      num_failures: watcher['no_remote_peer'] + watcher['rpcs_needed']
+    );
+  end
+end
+
+# send 1 rpc every 1/qps second
+def run_test_loop(stub, target_seconds_between_rpcs, fail_on_failed_rpcs)
+  include Grpc::Testing
+  req = SimpleRequest.new()
+  target_next_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  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
+    begin
+      deadline = GRPC::Core::TimeConsts::from_relative_time(30) # 30 seconds
+      resp = stub.unary_call(req, deadline: deadline)
+      remote_peer = resp.hostname
+    rescue GRPC::BadStatus => e
+      remote_peer = ""
+      GRPC.logger.info("ruby xds: rpc failed:|#{e.message}|, " \
+                       "this may or may not be expected")
+      if fail_on_failed_rpcs
+        raise e
+      end
+    end
+    $watchers_mutex.synchronize do
+      $watchers.each do |watcher|
+        watcher['rpcs_needed'] -= 1
+        if remote_peer.strip.empty?
+          watcher['no_remote_peer'] += 1
+        else
+          watcher['rpcs_by_peer'][remote_peer] += 1
+        end
+      end
+      $watchers_cv.broadcast
+    end
+  end
+end
+
+# Args is used to hold the command line info.
+Args = Struct.new(:fail_on_failed_rpcs, :num_channels,
+                  :server, :stats_port, :qps)
+
+# validates the command line options, returning them as a Hash.
+def parse_args
+  args = Args.new
+  args['fail_on_failed_rpcs'] = false
+  args['num_channels'] = 1
+  OptionParser.new do |opts|
+    opts.on('--fail_on_failed_rpcs BOOL', ['false', 'true']) do |v|
+      args['fail_on_failed_rpcs'] = v == 'true'
+    end
+    opts.on('--num_channels CHANNELS', 'number of channels') do |v|
+      args['num_channels'] = v.to_i
+    end
+    opts.on('--server SERVER_HOST', 'server hostname') do |v|
+      GRPC.logger.info("ruby xds: server address is #{v}")
+      args['server'] = v
+    end
+    opts.on('--stats_port STATS_PORT', 'stats port') do |v|
+      GRPC.logger.info("ruby xds: stats port is #{v}")
+      args['stats_port'] = v
+    end
+    opts.on('--qps QPS', 'qps') do |v|
+      GRPC.logger.info("ruby xds: qps is #{v}")
+      args['qps'] = v
+    end
+  end.parse!
+  args
+end
+
+def main
+  opts = parse_args
+
+  # This server hosts the LoadBalancerStatsService
+  host = "0.0.0.0:#{opts['stats_port']}"
+  s = GRPC::RpcServer.new
+  s.add_http2_port(host, :this_port_is_insecure)
+  s.handle(TestTarget)
+  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
+  stub = create_stub(opts)
+  target_seconds_between_rpcs = (1.0 / opts['qps'].to_f)
+  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'])
+    }
+  }
+
+  server_thread.join
+  $shutdown = true
+  client_threads.each { |thd| thd.join }
+end
+
+if __FILE__ == $0
+  main
+end

data/src/ruby/spec/debug_message_spec.rb

@@ -0,0 +1,134 @@
+# Copyright 2015 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.
+
+require 'spec_helper'
+
+TEST_DEBUG_MESSAGE = 'raised by test server'.freeze
+
+# a test service that checks the cert of its peer
+class DebugMessageTestService
+  include GRPC::GenericService
+  rpc :an_rpc_raises_abort, EchoMsg, EchoMsg
+  rpc :an_rpc_raises_standarderror, EchoMsg, EchoMsg
+
+  def an_rpc_raises_abort(_req, _call)
+    fail GRPC::Aborted.new(
+      'aborted',
+      {},
+      TEST_DEBUG_MESSAGE)
+  end
+
+  def an_rpc_raises_standarderror(_req, _call)
+    fail(StandardError, TEST_DEBUG_MESSAGE)
+  end
+end
+
+DebugMessageTestServiceStub = DebugMessageTestService.rpc_stub_class
+
+describe 'surfacing and transmitting of debug messages' do
+  RpcServer = GRPC::RpcServer
+
+  before(:all) do
+    server_opts = {
+      poll_period: 1
+    }
+    @srv = new_rpc_server_for_testing(**server_opts)
+    @port = @srv.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
+    @srv.handle(DebugMessageTestService)
+    @srv_thd = Thread.new { @srv.run }
+    @srv.wait_till_running
+  end
+
+  after(:all) do
+    expect(@srv.stopped?).to be(false)
+    @srv.stop
+    @srv_thd.join
+  end
+
+  it 'debug error message is not present BadStatus exceptions that dont set it' do
+    exception_message = ''
+    begin
+      fail GRPC::Unavailable('unavailable', {})
+    rescue StandardError => e
+      p "Got exception: #{e.message}"
+      exception_message = e.message
+    end
+    expect(exception_message.empty?).to be(false)
+    expect(exception_message.include?('debug_error_string')).to be(false)
+  end
+
+  it 'debug error message is present in locally generated errors' do
+    # Create a secure channel. This is just one way to force a
+    # connection handshake error, which shoud result in C-core
+    # generating a status and error message and surfacing them up.
+    test_root = File.join(File.dirname(__FILE__), 'testdata')
+    files = ['ca.pem', 'client.key', 'client.pem']
+    creds = files.map { |f| File.open(File.join(test_root, f)).read }
+    creds = GRPC::Core::ChannelCredentials.new(creds[0], creds[1], creds[2])
+    stub = DebugMessageTestServiceStub.new(
+      "localhost:#{@port}", creds)
+    begin
+      stub.an_rpc_raises_abort(EchoMsg.new)
+    rescue StandardError => e
+      p "Got exception: #{e.message}"
+      exception_message = e.message
+      # check that the RPC did actually result in a BadStatus exception
+      expect(e.is_a?(GRPC::BadStatus)).to be(true)
+    end
+    # just check that the debug_error_string is non-empty (we know that
+    # it's a JSON object, so the first character is '{').
+    expect(exception_message.include?('. debug_error_string:{')).to be(true)
+  end
+
+  it 'debug message is not transmitted from server to client' do
+    # in order to not accidentally leak internal details about a
+    # server to untrusted clients, avoid including the debug_error_string
+    # field of a BadStatusException raised at a server in the
+    # RPC status that it sends to clients.
+    stub = DebugMessageTestServiceStub.new(
+      "localhost:#{@port}", :this_channel_is_insecure)
+    exception_message = ''
+    begin
+      stub.an_rpc_raises_abort(EchoMsg.new)
+    rescue StandardError => e
+      p "Got exception: #{e.message}"
+      exception_message = e.message
+      # check that the status was aborted is an indirect way to
+      # tell that the RPC did actually get handled by the server
+      expect(e.is_a?(GRPC::Aborted)).to be(true)
+    end
+    # just assert that the contents of the server-side BadStatus
+    # debug_error_string field were *not* propagated to the client.
+    expect(exception_message.include?('. debug_error_string:{')).to be(true)
+    expect(exception_message.include?(TEST_DEBUG_MESSAGE)).to be(false)
+  end
+
+  it 'standard_error messages are transmitted from server to client' do
+    # this test exists mostly in order to understand the test case
+    # above, by comparison.
+    stub = DebugMessageTestServiceStub.new(
+      "localhost:#{@port}", :this_channel_is_insecure)
+    exception_message = ''
+    begin
+      stub.an_rpc_raises_standarderror(EchoMsg.new)
+    rescue StandardError => e
+      p "Got exception: #{e.message}"
+      exception_message = e.message
+      expect(e.is_a?(GRPC::BadStatus)).to be(true)
+    end
+    # assert that the contents of the StandardError exception message
+    # are propagated to the client.
+    expect(exception_message.include?(TEST_DEBUG_MESSAGE)).to be(true)
+  end
+end