grpc 1.33.0.pre1 → 1.37.0.pre1

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/spec/call_spec.rb

@@ -171,7 +171,7 @@ describe GRPC::Core::Call do
   end
 
   def make_test_call
-    @ch.create_call(nil, nil, 'dummy_method', nil, deadline)
+    @ch.create_call(nil, nil, 'phony_method', nil, deadline)
   end
 
   def deadline

data/src/ruby/spec/channel_credentials_spec.rb

@@ -60,6 +60,38 @@ describe GRPC::Core::ChannelCredentials do
       blk = proc { GRPC::Core::ChannelCredentials.new(nil, '', nil) }
       expect(&blk).to raise_error
     end
+
+    it 'can be constructed with a fallback credential' do
+      blk = proc {
+        fallback = GRPC::Core::ChannelCredentials.new
+        GRPC::Core::XdsChannelCredentials.new(fallback)
+      }
+      expect(&blk).not_to raise_error
+    end
+
+    it 'fails gracefully constructed with nil' do
+      blk = proc {
+        GRPC::Core::XdsChannelCredentials.new(nil)
+      }
+      expect(&blk).to raise_error TypeError, /expected grpc_channel_credentials/
+    end
+
+    it 'fails gracefully constructed with a non-C-extension object' do
+      blk = proc {
+        not_a_fallback = 100
+        GRPC::Core::XdsChannelCredentials.new(not_a_fallback)
+      }
+      expect(&blk).to raise_error TypeError, /expected grpc_channel_credentials/
+    end
+
+    it 'fails gracefully constructed with a non-ChannelCredentials object' do
+      blk = proc {
+        not_a_fallback = GRPC::Core::Channel.new('dummy_host', nil,
+                                                 :this_channel_is_insecure)
+        GRPC::Core::XdsChannelCredentials.new(not_a_fallback)
+      }
+      expect(&blk).to raise_error TypeError, /expected grpc_channel_credentials/
+    end
   end
 
   describe '#compose' do

data/src/ruby/spec/channel_spec.rb

@@ -53,7 +53,7 @@ describe GRPC::Core::Channel do
   shared_examples '#new' do
     it 'take a host name without channel args' do
       blk = proc do
-        GRPC::Core::Channel.new('dummy_host', nil, :this_channel_is_insecure)
+        GRPC::Core::Channel.new('phony_host', nil, :this_channel_is_insecure)
       end
       expect(&blk).not_to raise_error
     end
@@ -114,7 +114,7 @@ describe GRPC::Core::Channel do
 
   describe '#new for secure channels' do
     def construct_with_args(a)
-      proc { GRPC::Core::Channel.new('dummy_host', a, create_test_cert) }
+      proc { GRPC::Core::Channel.new('phony_host', a, create_test_cert) }
     end
 
     it_behaves_like '#new'
@@ -125,7 +125,18 @@ describe GRPC::Core::Channel do
 
     def construct_with_args(a)
       proc do
-        GRPC::Core::Channel.new('dummy_host', a, :this_channel_is_insecure)
+        GRPC::Core::Channel.new('phony_host', a, :this_channel_is_insecure)
+      end
+    end
+  end
+
+  describe '#new for XDS channels' do
+    it_behaves_like '#new'
+
+    def construct_with_args(a)
+      proc do
+        xds_creds = GRPC::Core::XdsChannelCredentials.new(create_test_cert)
+        GRPC::Core::Channel.new('dummy_host', a, xds_creds)
       end
     end
   end
@@ -137,7 +148,7 @@ describe GRPC::Core::Channel do
       deadline = Time.now + 5
 
       blk = proc do
-        ch.create_call(nil, nil, 'dummy_method', nil, deadline)
+        ch.create_call(nil, nil, 'phony_method', nil, deadline)
       end
       expect(&blk).to_not raise_error
     end
@@ -148,7 +159,7 @@ describe GRPC::Core::Channel do
 
       deadline = Time.now + 5
       blk = proc do
-        ch.create_call(nil, nil, 'dummy_method', nil, deadline)
+        ch.create_call(nil, nil, 'phony_method', nil, deadline)
       end
       expect(&blk).to raise_error(RuntimeError)
     end
@@ -160,7 +171,7 @@ describe GRPC::Core::Channel do
 
       blk = proc do
         fork_with_propagated_error_message do
-          ch.create_call(nil, nil, 'dummy_method', nil, deadline)
+          ch.create_call(nil, nil, 'phony_method', nil, deadline)
         end
       end
       expect(&blk).to raise_error(RuntimeError, 'grpc cannot be used before and after forking')

data/src/ruby/spec/client_auth_spec.rb

@@ -85,7 +85,10 @@ describe 'client-server auth' do
       poll_period: 1
     }
     @srv = new_rpc_server_for_testing(**server_opts)
-    port = @srv.add_http2_port('0.0.0.0:0', create_server_creds)
+    ssl_creds = create_server_creds
+    xds_creds = GRPC::Core::XdsServerCredentials.new(ssl_creds)
+    port = @srv.add_http2_port('0.0.0.0:0', ssl_creds)
+    xds_port = @srv.add_http2_port('0.0.0.0:0', xds_creds)
     @srv.handle(SslTestService)
     @srv_thd = Thread.new { @srv.run }
     @srv.wait_till_running
@@ -98,6 +101,11 @@ describe 'client-server auth' do
     @stub = SslTestServiceStub.new("localhost:#{port}",
                                    create_channel_creds,
                                    **client_opts)
+    # auth should success as the fallback creds wil be used
+    xds_channel_creds = GRPC::Core::XdsChannelCredentials.new(create_channel_creds)
+    @xds_stub = SslTestServiceStub.new("localhost:#{xds_port}",
+                                       xds_channel_creds,
+                                       **client_opts)
   end
 
   after(:all) do
@@ -123,4 +131,22 @@ describe 'client-server auth' do
     responses = @stub.a_bidi_rpc([EchoMsg.new, EchoMsg.new])
     responses.each { |r| GRPC.logger.info(r) }
   end
+
+  it 'xds_client-xds_server ssl fallback auth with unary RPCs' do
+    @xds_stub.an_rpc(EchoMsg.new)
+  end
+
+  it 'xds_client-xds_server ssl fallback auth with client streaming RPCs' do
+    @xds_stub.a_client_streaming_rpc([EchoMsg.new, EchoMsg.new])
+  end
+
+  it 'xds_client-xds_server ssl fallback auth with server streaming RPCs' do
+    responses = @xds_stub.a_server_streaming_rpc(EchoMsg.new)
+    responses.each { |r| GRPC.logger.info(r) }
+  end
+
+  it 'xds_client-xds_server ssl fallback auth with bidi RPCs' do
+    responses = @xds_stub.a_bidi_rpc([EchoMsg.new, EchoMsg.new])
+    responses.each { |r| GRPC.logger.info(r) }
+  end
 end

data/src/ruby/spec/errors_spec.rb

@@ -131,7 +131,7 @@ describe GRPC::BadStatus do
 
       error_msg = 'parse error: to_rpc_status failed'
       error_desc = '<Google::Protobuf::ParseError> ' \
-        'Error occurred during parsing: Invalid wire type'
+        'Error occurred during parsing'
 
       # Check that the parse error was logged correctly
       log_contents = @log_output.read

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

@@ -198,11 +198,11 @@ describe GRPC::ActiveCall do
         deadline,
         started: false)
 
-      metadata = { key: 'dummy_val', other: 'other_val' }
+      metadata = { key: 'phony_val', other: 'other_val' }
       expect(@client_call.metadata_sent).to eq(false)
       @client_call.merge_metadata_to_send(metadata)
 
-      message = 'dummy message'
+      message = 'phony message'
 
       expect(call).to(
         receive(:run_batch)

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

@@ -304,7 +304,7 @@ describe 'ClientStub' do  # rubocop:disable Metrics/BlockLength
 
     describe 'via a call operation' do
       after(:each) do
-        # make sure op.wait doesn't hang, even if there's a bad status
+        # make sure op.wait doesn't freeze, even if there's a bad status
         @op.wait
       end
       def get_response(stub, run_start_call_first: false, credentials: nil)
@@ -406,7 +406,7 @@ describe 'ClientStub' do  # rubocop:disable Metrics/BlockLength
 
     describe 'via a call operation' do
       after(:each) do
-        # make sure op.wait doesn't hang, even if there's a bad status
+        # make sure op.wait doesn't freeze, even if there's a bad status
         @op.wait
       end
       def get_response(stub, run_start_call_first: false)
@@ -547,7 +547,7 @@ describe 'ClientStub' do  # rubocop:disable Metrics/BlockLength
 
     describe 'via a call operation' do
       after(:each) do
-        @op.wait # make sure wait doesn't hang
+        @op.wait # make sure wait doesn't freeze
       end
       def get_responses(stub, run_start_call_first: false, unmarshal: noop)
         @op = stub.server_streamer(@method, @sent_msg, noop, unmarshal,
@@ -865,7 +865,7 @@ describe 'ClientStub' do  # rubocop:disable Metrics/BlockLength
 
     describe 'via a call operation' do
       after(:each) do
-        @op.wait # make sure wait doesn't hang
+        @op.wait # make sure wait doesn't freeze
       end
       def get_responses(stub, run_start_call_first: false, deadline: nil,
                         marshal_proc: noop)

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

@@ -104,7 +104,7 @@ end
 
 SynchronizedCancellationStub = SynchronizedCancellationService.rpc_stub_class
 
-# a test service that hangs onto call objects
+# a test service that holds onto call objects
 # and uses them after the server-side call has been
 # finished
 class CheckCallAfterFinishedService

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

@@ -71,14 +71,10 @@ describe 'Code Generation Options' do
 end
 
 def with_protos(file_paths)
-  fail 'CONFIG env variable unexpectedly unset' unless ENV['CONFIG']
-  bins_sub_dir = ENV['CONFIG']
-
   pb_dir = File.dirname(__FILE__)
-  bins_dir = File.join('..', '..', '..', '..', '..', 'bins', bins_sub_dir)
-
+  bins_dir = File.join('..', '..', '..', '..', '..', 'cmake', 'build')
   plugin = File.join(bins_dir, 'grpc_ruby_plugin')
-  protoc = File.join(bins_dir, 'protobuf', 'protoc')
+  protoc = File.join(bins_dir, 'third_party', 'protobuf', 'protoc')
 
   # Generate the service from the proto
   Dir.mktmpdir(nil, File.dirname(__FILE__)) do |tmp_dir|

data/src/ruby/spec/server_credentials_spec.rb

@@ -23,6 +23,7 @@ end
 
 describe GRPC::Core::ServerCredentials do
   Creds = GRPC::Core::ServerCredentials
+  XdsCreds = GRPC::Core::XdsServerCredentials
 
   describe '#new' do
     it 'can be constructed from a fake CA PEM, server PEM and a server key' do
@@ -75,5 +76,29 @@ describe GRPC::Core::ServerCredentials do
       blk = proc { Creds.new(nil, cert_pairs, false) }
       expect(&blk).to_not raise_error
     end
+
+    it 'can be constructed with a fallback credential' do
+      _, cert_pairs, _ = load_test_certs
+      fallback = Creds.new(nil, cert_pairs, false)
+      blk = proc { XdsCreds.new(fallback) }
+      expect(&blk).to_not raise_error
+    end
+
+    it 'cannot be constructed with nil' do
+      blk = proc { XdsCreds.new(nil) }
+      expect(&blk).to raise_error TypeError, /expected grpc_server_credentials/
+    end
+
+    it 'cannot be constructed with a non-C-extension object' do
+      not_a_fallback = 100
+      blk = proc { XdsCreds.new(not_a_fallback) }
+      expect(&blk).to raise_error TypeError, /expected grpc_server_credentials/
+    end
+
+    it 'cannot be constructed with a non-ServerCredentials object' do
+      not_a_fallback = GRPC::Core::ChannelCredentials.new
+      blk = proc { XdsCreds.new(not_a_fallback) }
+      expect(&blk).to raise_error TypeError, /expected grpc_server_credentials/
+    end
   end
 end

data/src/ruby/spec/server_spec.rb

@@ -139,6 +139,28 @@ describe Server do
         expect(&blk).to raise_error(RuntimeError)
       end
     end
+
+    describe 'for xds servers' do
+      let(:cert) { create_test_cert }
+      let(:xds) { GRPC::Core::XdsServerCredentials.new(cert) }
+      it 'runs without failing' do
+        blk = proc do
+          s = new_core_server_for_testing(nil)
+          s.add_http2_port('localhost:0', xds)
+          s.shutdown_and_notify(nil)
+          s.close
+        end
+        expect(&blk).to_not raise_error
+      end
+
+      it 'fails if the server is closed' do
+        s = new_core_server_for_testing(nil)
+        s.shutdown_and_notify(nil)
+        s.close
+        blk = proc { s.add_http2_port('localhost:0', xds) }
+        expect(&blk).to raise_error(RuntimeError)
+      end
+    end
   end
 
   shared_examples '#new' do