grpc 1.28.0 → 1.31.0.pre2

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

@@ -23,13 +23,12 @@ class Struct
     # is non-nil and not OK.
     def check_status
       return nil if status.nil?
-      fail GRPC::Cancelled if status.code == GRPC::Core::StatusCodes::CANCELLED
       if status.code != GRPC::Core::StatusCodes::OK
         GRPC.logger.debug("Failing with status #{status}")
         # raise BadStatus, propagating the metadata if present.
-        md = status.metadata
         fail GRPC::BadStatus.new_status_exception(
-          status.code, status.details, md)
+          status.code, status.details, status.metadata,
+          status.debug_error_string)
       end
       status
     end

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

@@ -38,7 +38,7 @@ module GRPC
     #
     # @param [Object] request
     # @param [GRPC::ActiveCall] call
-    # @param [Method] method
+    # @param [String] method
     # @param [Hash] metadata
     #
     def request_response(request: nil, call: nil, method: nil, metadata: nil)
@@ -52,7 +52,7 @@ module GRPC
     #
     # @param [Enumerable] requests
     # @param [GRPC::ActiveCall] call
-    # @param [Method] method
+    # @param [String] method
     # @param [Hash] metadata
     #
     def client_streamer(requests: nil, call: nil, method: nil, metadata: nil)
@@ -66,7 +66,7 @@ module GRPC
     #
     # @param [Object] request
     # @param [GRPC::ActiveCall] call
-    # @param [Method] method
+    # @param [String] method
     # @param [Hash] metadata
     #
     def server_streamer(request: nil, call: nil, method: nil, metadata: nil)
@@ -80,7 +80,7 @@ module GRPC
     #
     # @param [Enumerable] requests
     # @param [GRPC::ActiveCall] call
-    # @param [Method] method
+    # @param [String] method
     # @param [Hash] metadata
     #
     def bidi_streamer(requests: nil, call: nil, method: nil, metadata: nil)
@@ -172,7 +172,7 @@ module GRPC
       i = @interceptors.pop
       return yield unless i
 
-      i.send(type, args) do
+      i.send(type, **args) do
         if @interceptors.any?
           intercept!(type, args) do
             yield

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

@@ -391,22 +391,21 @@ module GRPC
       # register signal handlers
       signals.each do |sig|
         # input validation
-        if sig.class == String
-          sig.upcase!
-          if sig.start_with?('SIG')
-            # cut out the SIG prefix to see if valid signal
-            sig = sig[3..-1]
-          end
-        end
+        target_sig = if sig.class == String
+                       # cut out the SIG prefix to see if valid signal
+                       sig.upcase.start_with?('SIG') ? sig.upcase[3..-1] : sig.upcase
+                     else
+                       sig
+                     end
 
         # register signal traps for all valid signals
-        if valid_signals.value?(sig) || valid_signals.key?(sig)
-          Signal.trap(sig) do
+        if valid_signals.value?(target_sig) || valid_signals.key?(target_sig)
+          Signal.trap(target_sig) do
             @stop_server = true
             @stop_server_cv.broadcast
           end
         else
-          fail "#{sig} not a valid signal"
+          fail "#{target_sig} not a valid signal"
         end
       end
 

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'
+  VERSION = '1.31.0.pre2'
 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/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

data/src/ruby/spec/generic/service_spec.rb

@@ -55,6 +55,8 @@ describe GenericService do
       expect(GenericService.underscore('AMethod')).to eq('a_method')
       expect(GenericService.underscore('PrintHTML')).to eq('print_html')
       expect(GenericService.underscore('SeeHTMLBooks')).to eq('see_html_books')
+
+      expect(GenericService.underscore('SeeHTMLBooks'.freeze)).to eq('see_html_books')
     end
   end
 

data/src/ruby/spec/pb/codegen/grpc/testing/package_options_import2.proto

@@ -0,0 +1,23 @@
+// Copyright 2020 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.
+
+syntax = "proto3";
+
+package grpc.foo;
+
+option ruby_package = "B::Other";
+
+message Foo {
+  message Bar { }
+}

data/src/ruby/spec/pb/codegen/grpc/testing/package_options_ruby_style.proto

@@ -17,6 +17,7 @@ syntax = "proto3";
 package grpc.testing;
 
 import "grpc/testing/package_options_import.proto";
+import "grpc/testing/package_options_import2.proto";
 
 // For sanity checking package definitions
 option ruby_package = "RPC::Test::New::Package::Options";
@@ -27,8 +28,14 @@ message AnotherTestResponse { }
 
 message Foo { }
 
+message Bar {
+  message Baz { }
+}
+
 service AnotherTestService {
   rpc GetTest(AnotherTestRequest) returns (AnotherTestResponse) { }
   rpc OtherTest(Thing) returns (Thing) { }
+  rpc PackageTest(grpc.testing.Thing) returns (grpc.foo.Foo.Bar) { }
   rpc FooTest(Foo) returns (Foo) { }
+  rpc NestedMessageTest(Foo) returns (Bar.Baz) { }
 }

data/src/ruby/spec/pb/codegen/package_option_spec.rb

@@ -27,7 +27,9 @@ describe 'Code Generation Options' do
   end
 
   it 'should generate and respect Ruby style package options' do
-    with_protos(%w[grpc/testing/package_options_ruby_style.proto grpc/testing/package_options_import.proto]) do
+    with_protos(['grpc/testing/package_options_ruby_style.proto',
+                 'grpc/testing/package_options_import.proto',
+                 'grpc/testing/package_options_import2.proto']) do
       expect { RPC::Test::New::Package::Options::AnotherTestService::Service }.to raise_error(NameError)
       expect(require('grpc/testing/package_options_ruby_style_services_pb')).to be_truthy
       expect { RPC::Test::New::Package::Options::AnotherTestService::Service }.to_not raise_error
@@ -38,8 +40,12 @@ describe 'Code Generation Options' do
       expect(services[:GetTest].output).to eq(RPC::Test::New::Package::Options::AnotherTestResponse)
       expect(services[:OtherTest].input).to eq(A::Other::Thing)
       expect(services[:OtherTest].output).to eq(A::Other::Thing)
+      expect(services[:PackageTest].input).to eq(A::Other::Thing)
+      expect(services[:PackageTest].output).to eq(B::Other::Foo::Bar)
       expect(services[:FooTest].input).to eq(RPC::Test::New::Package::Options::Foo)
       expect(services[:FooTest].output).to eq(RPC::Test::New::Package::Options::Foo)
+      expect(services[:NestedMessageTest].input).to eq(RPC::Test::New::Package::Options::Foo)
+      expect(services[:NestedMessageTest].output).to eq(RPC::Test::New::Package::Options::Bar::Baz)
     end
   end
 end

data/src/ruby/spec/support/services.rb

@@ -17,12 +17,18 @@ require 'spec_helper'
 
 # A test message
 class EchoMsg
-  def self.marshal(_o)
-    ''
+  attr_reader :msg
+
+  def initialize(msg: '')
+    @msg = msg
   end
 
-  def self.unmarshal(_o)
-    EchoMsg.new
+  def self.marshal(o)
+    o.msg
+  end
+
+  def self.unmarshal(msg)
+    EchoMsg.new(msg: msg)
   end
 end