grpc 1.6.7 → 1.7.0.pre1

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

@@ -47,43 +47,85 @@ module GRPC
       proc { |o| unmarshal_class.method(unmarshal_method).call(o) }
     end
 
-    def handle_request_response(active_call, mth)
+    def handle_request_response(active_call, mth, inter_ctx)
       req = active_call.read_unary_request
-      resp = mth.call(req, active_call.single_req_view)
-      active_call.server_unary_response(
-        resp, trailing_metadata: active_call.output_metadata)
+      call = active_call.single_req_view
+
+      inter_ctx.intercept!(
+        :request_response,
+        method: mth,
+        call: call,
+        request: req
+      ) do
+        resp = mth.call(req, call)
+        active_call.server_unary_response(
+          resp,
+          trailing_metadata: active_call.output_metadata
+        )
+      end
     end
 
-    def handle_client_streamer(active_call,  mth)
-      resp = mth.call(active_call.multi_req_view)
-      active_call.server_unary_response(
-        resp, trailing_metadata: active_call.output_metadata)
+    def handle_client_streamer(active_call, mth, inter_ctx)
+      call = active_call.multi_req_view
+
+      inter_ctx.intercept!(
+        :client_streamer,
+        method: mth,
+        call: call
+      ) do
+        resp = mth.call(call)
+        active_call.server_unary_response(
+          resp,
+          trailing_metadata: active_call.output_metadata
+        )
+      end
     end
 
-    def handle_server_streamer(active_call, mth)
+    def handle_server_streamer(active_call, mth, inter_ctx)
       req = active_call.read_unary_request
-      replys = mth.call(req, active_call.single_req_view)
-      replys.each { |r| active_call.remote_send(r) }
-      send_status(active_call, OK, 'OK', active_call.output_metadata)
+      call = active_call.single_req_view
+
+      inter_ctx.intercept!(
+        :server_streamer,
+        method: mth,
+        call: call,
+        request: req
+      ) do
+        replies = mth.call(req, call)
+        replies.each { |r| active_call.remote_send(r) }
+        send_status(active_call, OK, 'OK', active_call.output_metadata)
+      end
     end
 
-    def handle_bidi_streamer(active_call, mth)
-      active_call.run_server_bidi(mth)
+    ##
+    # @param [GRPC::ActiveCall] active_call
+    # @param [Method] mth
+    # @param [Array<GRPC::InterceptionContext>] inter_ctx
+    #
+    def handle_bidi_streamer(active_call, mth, inter_ctx)
+      active_call.run_server_bidi(mth, inter_ctx)
       send_status(active_call, OK, 'OK', active_call.output_metadata)
     end
 
-    def run_server_method(active_call, mth)
+    ##
+    # @param [GRPC::ActiveCall] active_call The current active call object
+    #   for the request
+    # @param [Method] mth The current RPC method being called
+    # @param [GRPC::InterceptionContext] inter_ctx The interception context
+    #   being executed
+    #
+    def run_server_method(active_call, mth, inter_ctx = InterceptionContext.new)
       # While a server method is running, it might be cancelled, its deadline
       # might be reached, the handler could throw an unknown error, or a
       # well-behaved handler could throw a StatusError.
       if request_response?
-        handle_request_response(active_call, mth)
+        handle_request_response(active_call, mth, inter_ctx)
       elsif client_streamer?
-        handle_client_streamer(active_call, mth)
+        handle_client_streamer(active_call, mth, inter_ctx)
       elsif server_streamer?
-        handle_server_streamer(active_call, mth)
+        handle_server_streamer(active_call, mth, inter_ctx)
       else  # is a bidi_stream
-        handle_bidi_streamer(active_call, mth)
+        handle_bidi_streamer(active_call, mth, inter_ctx)
       end
     rescue BadStatus => e
       # this is raised by handlers that want GRPC to send an application error
@@ -99,9 +141,13 @@ module GRPC
       # event.  Send a status of deadline exceeded
       GRPC.logger.warn("late call: #{active_call}")
       send_status(active_call, DEADLINE_EXCEEDED, 'late')
-    rescue StandardError => e
+    rescue StandardError, NotImplementedError => e
       # This will usuaally be an unhandled error in the handling code.
       # Send back a UNKNOWN status to the client
+      #
+      # Note: this intentionally does not map NotImplementedError to
+      # UNIMPLEMENTED because NotImplementedError is intended for low-level
+      # OS interaction (e.g. syscalls) not supported by the current OS.
       GRPC.logger.warn("failed handler: #{active_call}; sending status:UNKNOWN")
       GRPC.logger.warn(e)
       send_status(active_call, UNKNOWN, "#{e.class}: #{e.message}")

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

@@ -196,11 +196,18 @@ module GRPC
     #
     # * server_args:
     # A server arguments hash to be passed down to the underlying core server
+    #
+    # * interceptors:
+    # Am array of GRPC::ServerInterceptor objects that will be used for
+    # intercepting server handlers to provide extra functionality.
+    # Interceptors are an EXPERIMENTAL API.
+    #
     def initialize(pool_size:DEFAULT_POOL_SIZE,
                    max_waiting_requests:DEFAULT_MAX_WAITING_REQUESTS,
                    poll_period:DEFAULT_POLL_PERIOD,
                    connect_md_proc:nil,
-                   server_args:{})
+                   server_args:{},
+                   interceptors:[])
       @connect_md_proc = RpcServer.setup_connect_md_proc(connect_md_proc)
       @max_waiting_requests = max_waiting_requests
       @poll_period = poll_period
@@ -212,6 +219,7 @@ module GRPC
       # :stopped. State transitions can only proceed in that order.
       @running_state = :not_started
       @server = Core::Server.new(server_args)
+      @interceptors = InterceptorRegistry.new(interceptors)
     end
 
     # stops a running server
@@ -374,7 +382,11 @@ module GRPC
             @pool.schedule(active_call) do |ac|
               c, mth = ac
               begin
-                rpc_descs[mth].run_server_method(c, rpc_handlers[mth])
+                rpc_descs[mth].run_server_method(
+                  c,
+                  rpc_handlers[mth],
+                  @interceptors.build_context
+                )
               rescue StandardError
                 c.send_status(GRPC::Core::StatusCodes::INTERNAL,
                               'Server handler failed')
@@ -382,7 +394,7 @@ module GRPC
             end
           end
         rescue Core::CallError, RuntimeError => e
-          # these might happen for various reasonse.  The correct behaviour of
+          # these might happen for various reasons.  The correct behavior of
           # the server is to log them and continue, if it's not shutting down.
           if running_state == :running
             GRPC.logger.warn("server call failed: #{e}")

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

@@ -29,8 +29,7 @@ module GRPC
       fail ArgumentError, 'bad type' unless status.is_a? Struct::Status
       grpc_status_details_bin_trailer = 'grpc-status-details-bin'
       return nil if status.metadata[grpc_status_details_bin_trailer].nil?
-      Google::Rpc::Status.decode(
-        status.metadata[grpc_status_details_bin_trailer])
+      Google::Rpc::Status.decode(status.metadata[grpc_status_details_bin_trailer])
     end
   end
 end

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

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

data/src/ruby/pb/grpc/testing/duplicate/echo_duplicate_services_pb.rb

@@ -34,6 +34,7 @@ module Grpc
           self.service_name = 'grpc.testing.duplicate.EchoTestService'
 
           rpc :Echo, Grpc::Testing::EchoRequest, Grpc::Testing::EchoResponse
+          rpc :ResponseStream, Grpc::Testing::EchoRequest, stream(Grpc::Testing::EchoResponse)
         end
 
         Stub = Service.rpc_stub_class

data/src/ruby/spec/channel_connection_spec.rb

@@ -11,45 +11,12 @@
 # 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 'grpc'
+require 'spec_helper'
 require 'timeout'
 
 include Timeout
 include GRPC::Core
 
-# A test message
-class EchoMsg
-  def self.marshal(_o)
-    ''
-  end
-
-  def self.unmarshal(_o)
-    EchoMsg.new
-  end
-end
-
-# A test service with an echo implementation.
-class EchoService
-  include GRPC::GenericService
-  rpc :an_rpc, EchoMsg, EchoMsg
-  attr_reader :received_md
-
-  def initialize(**kw)
-    @trailing_metadata = kw
-    @received_md = []
-  end
-
-  def an_rpc(req, call)
-    GRPC.logger.info('echo service received a request')
-    call.output_metadata.update(@trailing_metadata)
-    @received_md << call.metadata unless call.metadata.nil?
-    req
-  end
-end
-
-EchoStub = EchoService.rpc_stub_class
-
 def start_server(port = 0)
   @srv = GRPC::RpcServer.new(pool_size: 1)
   server_port = @srv.add_http2_port("localhost:#{port}", :this_port_is_insecure)

data/src/ruby/spec/client_server_spec.rb

@@ -29,14 +29,18 @@ shared_context 'setup: tags' do
     expect(recvd_rpc).to_not eq nil
     server_call = recvd_rpc.call
     ops = { CallOps::SEND_INITIAL_METADATA => metadata }
-    svr_batch = server_call.run_batch(ops)
-    expect(svr_batch.send_metadata).to be true
+    server_batch = server_call.run_batch(ops)
+    expect(server_batch.send_metadata).to be true
     server_call
   end
 
   def new_client_call
     @ch.create_call(nil, nil, '/method', nil, deadline)
   end
+
+  def ok_status
+    Struct::Status.new(StatusCodes::OK, 'OK')
+  end
 end
 
 shared_examples 'basic GRPC message delivery is OK' do
@@ -70,19 +74,32 @@ shared_examples 'basic GRPC message delivery is OK' do
 
     client_ops = {
       CallOps::SEND_INITIAL_METADATA => {},
-      CallOps::SEND_MESSAGE => sent_message
+      CallOps::SEND_MESSAGE => sent_message,
+      CallOps::SEND_CLOSE_FROM_CLIENT => nil
     }
-    batch_result = call.run_batch(client_ops)
-    expect(batch_result.send_metadata).to be true
-    expect(batch_result.send_message).to be true
+    client_batch = call.run_batch(client_ops)
+    expect(client_batch.send_metadata).to be true
+    expect(client_batch.send_message).to be true
+    expect(client_batch.send_close).to be true
 
     # confirm the server can read the inbound message
     server_thread.join
     server_ops = {
-      CallOps::RECV_MESSAGE => nil
+      CallOps::RECV_MESSAGE => nil,
+      CallOps::RECV_CLOSE_ON_SERVER => nil,
+      CallOps::SEND_STATUS_FROM_SERVER => ok_status
     }
-    svr_batch = server_call.run_batch(server_ops)
-    expect(svr_batch.message).to eq(sent_message)
+    server_batch = server_call.run_batch(server_ops)
+    expect(server_batch.message).to eq(sent_message)
+    expect(server_batch.send_close).to be true
+    expect(server_batch.send_status).to be true
+
+    # finish the call
+    final_client_batch = call.run_batch(
+      CallOps::RECV_INITIAL_METADATA => nil,
+      CallOps::RECV_STATUS_ON_CLIENT => nil)
+    expect(final_client_batch.metadata).to eq({})
+    expect(final_client_batch.status.code).to eq(0)
   end
 
   it 'responses written by servers are received by the client' do
@@ -95,21 +112,36 @@ shared_examples 'basic GRPC message delivery is OK' do
 
     client_ops = {
       CallOps::SEND_INITIAL_METADATA => {},
-      CallOps::SEND_MESSAGE => sent_message
+      CallOps::SEND_MESSAGE => sent_message,
+      CallOps::SEND_CLOSE_FROM_CLIENT => nil
     }
-    batch_result = call.run_batch(client_ops)
-    expect(batch_result.send_metadata).to be true
-    expect(batch_result.send_message).to be true
+    client_batch = call.run_batch(client_ops)
+    expect(client_batch.send_metadata).to be true
+    expect(client_batch.send_message).to be true
+    expect(client_batch.send_close).to be true
 
     # confirm the server can read the inbound message
     server_thread.join
     server_ops = {
       CallOps::RECV_MESSAGE => nil,
-      CallOps::SEND_MESSAGE => reply_text
+      CallOps::RECV_CLOSE_ON_SERVER => nil,
+      CallOps::SEND_MESSAGE => reply_text,
+      CallOps::SEND_STATUS_FROM_SERVER => ok_status
     }
-    svr_batch = server_call.run_batch(server_ops)
-    expect(svr_batch.message).to eq(sent_message)
-    expect(svr_batch.send_message).to be true
+    server_batch = server_call.run_batch(server_ops)
+    expect(server_batch.message).to eq(sent_message)
+    expect(server_batch.send_close).to be true
+    expect(server_batch.send_message).to be true
+    expect(server_batch.send_status).to be true
+
+    # finish the call
+    final_client_batch = call.run_batch(
+      CallOps::RECV_INITIAL_METADATA => nil,
+      CallOps::RECV_MESSAGE => nil,
+      CallOps::RECV_STATUS_ON_CLIENT => nil)
+    expect(final_client_batch.metadata).to eq({})
+    expect(final_client_batch.message).to eq(reply_text)
+    expect(final_client_batch.status.code).to eq(0)
   end
 
   it 'compressed messages can be sent and received' do
@@ -125,30 +157,37 @@ shared_examples 'basic GRPC message delivery is OK' do
 
     client_ops = {
       CallOps::SEND_INITIAL_METADATA => md,
-      CallOps::SEND_MESSAGE => long_request_str
+      CallOps::SEND_MESSAGE => long_request_str,
+      CallOps::SEND_CLOSE_FROM_CLIENT => nil
     }
-    batch_result = call.run_batch(client_ops)
-    expect(batch_result.send_metadata).to be true
-    expect(batch_result.send_message).to be true
+    client_batch = call.run_batch(client_ops)
+    expect(client_batch.send_metadata).to be true
+    expect(client_batch.send_message).to be true
+    expect(client_batch.send_close).to be true
 
     # confirm the server can read the inbound message
     server_thread.join
     server_ops = {
       CallOps::RECV_MESSAGE => nil,
-      CallOps::SEND_MESSAGE => long_response_str
+      CallOps::RECV_CLOSE_ON_SERVER => nil,
+      CallOps::SEND_MESSAGE => long_response_str,
+      CallOps::SEND_STATUS_FROM_SERVER => ok_status
     }
-    svr_batch = server_call.run_batch(server_ops)
-    expect(svr_batch.message).to eq(long_request_str)
-    expect(svr_batch.send_message).to be true
+    server_batch = server_call.run_batch(server_ops)
+    expect(server_batch.message).to eq(long_request_str)
+    expect(server_batch.send_close).to be true
+    expect(server_batch.send_message).to be true
+    expect(server_batch.send_status).to be true
 
     client_ops = {
-      CallOps::SEND_CLOSE_FROM_CLIENT => nil,
       CallOps::RECV_INITIAL_METADATA => nil,
-      CallOps::RECV_MESSAGE => nil
+      CallOps::RECV_MESSAGE => nil,
+      CallOps::RECV_STATUS_ON_CLIENT => nil
     }
-    batch_result = call.run_batch(client_ops)
-    expect(batch_result.send_close).to be true
-    expect(batch_result.message).to eq long_response_str
+    final_client_batch = call.run_batch(client_ops)
+    expect(final_client_batch.metadata).to eq({})
+    expect(final_client_batch.message).to eq long_response_str
+    expect(final_client_batch.status.code).to eq(0)
   end
 
   it 'servers can ignore a client write and send a status' do
@@ -161,11 +200,13 @@ shared_examples 'basic GRPC message delivery is OK' do
 
     client_ops = {
       CallOps::SEND_INITIAL_METADATA => {},
-      CallOps::SEND_MESSAGE => sent_message
+      CallOps::SEND_MESSAGE => sent_message,
+      CallOps::SEND_CLOSE_FROM_CLIENT => nil
     }
-    batch_result = call.run_batch(client_ops)
-    expect(batch_result.send_metadata).to be true
-    expect(batch_result.send_message).to be true
+    client_batch = call.run_batch(client_ops)
+    expect(client_batch.send_metadata).to be true
+    expect(client_batch.send_message).to be true
+    expect(client_batch.send_close).to be true
 
     # confirm the server can read the inbound message
     the_status = Struct::Status.new(StatusCodes::OK, 'OK')
@@ -173,9 +214,15 @@ shared_examples 'basic GRPC message delivery is OK' do
     server_ops = {
       CallOps::SEND_STATUS_FROM_SERVER => the_status
     }
-    svr_batch = server_call.run_batch(server_ops)
-    expect(svr_batch.message).to eq nil
-    expect(svr_batch.send_status).to be true
+    server_batch = server_call.run_batch(server_ops)
+    expect(server_batch.message).to eq nil
+    expect(server_batch.send_status).to be true
+
+    final_client_batch = call.run_batch(
+      CallOps::RECV_INITIAL_METADATA => nil,
+      CallOps::RECV_STATUS_ON_CLIENT => nil)
+    expect(final_client_batch.metadata).to eq({})
+    expect(final_client_batch.status.code).to eq(0)
   end
 
   it 'completes calls by sending status to client and server' do
@@ -190,9 +237,9 @@ shared_examples 'basic GRPC message delivery is OK' do
       CallOps::SEND_INITIAL_METADATA => {},
       CallOps::SEND_MESSAGE => sent_message
     }
-    batch_result = call.run_batch(client_ops)
-    expect(batch_result.send_metadata).to be true
-    expect(batch_result.send_message).to be true
+    client_batch = call.run_batch(client_ops)
+    expect(client_batch.send_metadata).to be true
+    expect(client_batch.send_message).to be true
 
     # confirm the server can read the inbound message and respond
     the_status = Struct::Status.new(StatusCodes::OK, 'OK', {})
@@ -202,10 +249,10 @@ shared_examples 'basic GRPC message delivery is OK' do
       CallOps::SEND_MESSAGE => reply_text,
       CallOps::SEND_STATUS_FROM_SERVER => the_status
     }
-    svr_batch = server_call.run_batch(server_ops)
-    expect(svr_batch.message).to eq sent_message
-    expect(svr_batch.send_status).to be true
-    expect(svr_batch.send_message).to be true
+    server_batch = server_call.run_batch(server_ops)
+    expect(server_batch.message).to eq sent_message
+    expect(server_batch.send_status).to be true
+    expect(server_batch.send_message).to be true
 
     # confirm the client can receive the server response and status.
     client_ops = {
@@ -214,17 +261,17 @@ shared_examples 'basic GRPC message delivery is OK' do
       CallOps::RECV_MESSAGE => nil,
       CallOps::RECV_STATUS_ON_CLIENT => nil
     }
-    batch_result = call.run_batch(client_ops)
-    expect(batch_result.send_close).to be true
-    expect(batch_result.message).to eq reply_text
-    expect(batch_result.status).to eq the_status
+    final_client_batch = call.run_batch(client_ops)
+    expect(final_client_batch.send_close).to be true
+    expect(final_client_batch.message).to eq reply_text
+    expect(final_client_batch.status).to eq the_status
 
     # confirm the server can receive the client close.
     server_ops = {
       CallOps::RECV_CLOSE_ON_SERVER => nil
     }
-    svr_batch = server_call.run_batch(server_ops)
-    expect(svr_batch.send_close).to be true
+    final_server_batch = server_call.run_batch(server_ops)
+    expect(final_server_batch.send_close).to be true
   end
 
   def client_cancel_test(cancel_proc, expected_code,
@@ -240,9 +287,9 @@ shared_examples 'basic GRPC message delivery is OK' do
       CallOps::SEND_INITIAL_METADATA => {},
       CallOps::RECV_INITIAL_METADATA => nil
     }
-    batch_result = call.run_batch(client_ops)
-    expect(batch_result.send_metadata).to be true
-    expect(batch_result.metadata).to eq({})
+    client_batch = call.run_batch(client_ops)
+    expect(client_batch.send_metadata).to be true
+    expect(client_batch.metadata).to eq({})
 
     cancel_proc.call(call)
 
@@ -250,16 +297,16 @@ shared_examples 'basic GRPC message delivery is OK' do
     server_ops = {
       CallOps::RECV_CLOSE_ON_SERVER => nil
     }
-    svr_batch = server_call.run_batch(server_ops)
-    expect(svr_batch.send_close).to be true
+    server_batch = server_call.run_batch(server_ops)
+    expect(server_batch.send_close).to be true
 
     client_ops = {
       CallOps::RECV_STATUS_ON_CLIENT => {}
     }
-    batch_result = call.run_batch(client_ops)
+    client_batch = call.run_batch(client_ops)
 
-    expect(batch_result.status.code).to be expected_code
-    expect(batch_result.status.details).to eq expected_details
+    expect(client_batch.status.code).to be expected_code
+    expect(client_batch.status.details).to eq expected_details
   end
 
   it 'clients can cancel a call on the server' do
@@ -325,10 +372,11 @@ shared_examples 'GRPC metadata delivery works OK' do
 
         call = new_client_call
         client_ops = {
-          CallOps::SEND_INITIAL_METADATA => md
+          CallOps::SEND_INITIAL_METADATA => md,
+          CallOps::SEND_CLOSE_FROM_CLIENT => nil
         }
-        batch_result = call.run_batch(client_ops)
-        expect(batch_result.send_metadata).to be true
+        client_batch = call.run_batch(client_ops)
+        expect(client_batch.send_metadata).to be true
 
         # confirm the server can receive the client metadata
         rcv_thread.join
@@ -336,6 +384,21 @@ shared_examples 'GRPC metadata delivery works OK' do
         recvd_md = recvd_rpc.metadata
         replace_symbols = Hash[md.each_pair.collect { |x, y| [x.to_s, y] }]
         expect(recvd_md).to eq(recvd_md.merge(replace_symbols))
+
+        # finish the call
+        final_server_batch = recvd_rpc.call.run_batch(
+          CallOps::RECV_CLOSE_ON_SERVER => nil,
+          CallOps::SEND_INITIAL_METADATA => nil,
+          CallOps::SEND_STATUS_FROM_SERVER => ok_status)
+        expect(final_server_batch.send_close).to be(true)
+        expect(final_server_batch.send_metadata).to be(true)
+        expect(final_server_batch.send_status).to be(true)
+
+        final_client_batch = call.run_batch(
+          CallOps::RECV_INITIAL_METADATA => nil,
+          CallOps::RECV_STATUS_ON_CLIENT => nil)
+        expect(final_client_batch.metadata).to eq({})
+        expect(final_client_batch.status.code).to eq(0)
       end
     end
   end
@@ -381,6 +444,9 @@ shared_examples 'GRPC metadata delivery works OK' do
           recvd_rpc.call.run_batch(server_ops)
         end
         expect(&blk).to raise_error
+
+        # cancel the call so the server can shut down immediately
+        call.cancel
       end
     end
 
@@ -394,25 +460,37 @@ shared_examples 'GRPC metadata delivery works OK' do
       # client signals that it's done sending metadata to allow server to
       # respond
       client_ops = {
-        CallOps::SEND_INITIAL_METADATA => nil
+        CallOps::SEND_INITIAL_METADATA => nil,
+        CallOps::SEND_CLOSE_FROM_CLIENT => nil
       }
-      call.run_batch(client_ops)
+      client_batch = call.run_batch(client_ops)
+      expect(client_batch.send_metadata).to be true
+      expect(client_batch.send_close).to be true
 
       # server gets the invocation but sends no metadata back
       rcv_thread.join
       expect(recvd_rpc).to_not eq nil
       server_call = recvd_rpc.call
       server_ops = {
-        CallOps::SEND_INITIAL_METADATA => nil
+        # receive close and send status to finish the call
+        CallOps::RECV_CLOSE_ON_SERVER => nil,
+        CallOps::SEND_INITIAL_METADATA => nil,
+        CallOps::SEND_STATUS_FROM_SERVER => ok_status
       }
-      server_call.run_batch(server_ops)
+      srv_batch = server_call.run_batch(server_ops)
+      expect(srv_batch.send_close).to be true
+      expect(srv_batch.send_metadata).to be true
+      expect(srv_batch.send_status).to be true
 
       # client receives nothing as expected
       client_ops = {
-        CallOps::RECV_INITIAL_METADATA => nil
+        CallOps::RECV_INITIAL_METADATA => nil,
+        # receive status to finish the call
+        CallOps::RECV_STATUS_ON_CLIENT => nil
       }
-      batch_result = call.run_batch(client_ops)
-      expect(batch_result.metadata).to eq({})
+      final_client_batch = call.run_batch(client_ops)
+      expect(final_client_batch.metadata).to eq({})
+      expect(final_client_batch.status.code).to eq(0)
     end
 
     it 'sends all the pairs when keys and values are valid' do
@@ -426,26 +504,36 @@ shared_examples 'GRPC metadata delivery works OK' do
         # client signals that it's done sending metadata to allow server to
         # respond
         client_ops = {
-          CallOps::SEND_INITIAL_METADATA => nil
+          CallOps::SEND_INITIAL_METADATA => nil,
+          CallOps::SEND_CLOSE_FROM_CLIENT => nil
         }
-        call.run_batch(client_ops)
+        client_batch = call.run_batch(client_ops)
+        expect(client_batch.send_metadata).to be true
+        expect(client_batch.send_close).to be true
 
         # server gets the invocation but sends no metadata back
         rcv_thread.join
         expect(recvd_rpc).to_not eq nil
         server_call = recvd_rpc.call
         server_ops = {
-          CallOps::SEND_INITIAL_METADATA => md
+          CallOps::RECV_CLOSE_ON_SERVER => nil,
+          CallOps::SEND_INITIAL_METADATA => md,
+          CallOps::SEND_STATUS_FROM_SERVER => ok_status
         }
-        server_call.run_batch(server_ops)
+        srv_batch = server_call.run_batch(server_ops)
+        expect(srv_batch.send_close).to be true
+        expect(srv_batch.send_metadata).to be true
+        expect(srv_batch.send_status).to be true
 
         # client receives nothing as expected
         client_ops = {
-          CallOps::RECV_INITIAL_METADATA => nil
+          CallOps::RECV_INITIAL_METADATA => nil,
+          CallOps::RECV_STATUS_ON_CLIENT => nil
         }
-        batch_result = call.run_batch(client_ops)
+        final_client_batch = call.run_batch(client_ops)
         replace_symbols = Hash[md.each_pair.collect { |x, y| [x.to_s, y] }]
-        expect(batch_result.metadata).to eq(replace_symbols)
+        expect(final_client_batch.metadata).to eq(replace_symbols)
+        expect(final_client_batch.status.code).to eq(0)
       end
     end
   end
@@ -510,8 +598,7 @@ describe 'the secure http client/server' do
 
     initial_md_key = 'k2'
     initial_md_val = 'v2'
-    initial_md = {}
-    initial_md[initial_md_key] = initial_md_val
+    initial_md = { initial_md_key => initial_md_val }
     expected_md = creds_update_md.clone
     fail 'bad test param' unless expected_md[initial_md_key].nil?
     expected_md[initial_md_key] = initial_md_val
@@ -523,11 +610,12 @@ describe 'the secure http client/server' do
 
     call = new_client_call
     call.set_credentials! call_creds
-    client_ops = {
-      CallOps::SEND_INITIAL_METADATA => initial_md
-    }
-    batch_result = call.run_batch(client_ops)
-    expect(batch_result.send_metadata).to be true
+
+    client_batch = call.run_batch(
+      CallOps::SEND_INITIAL_METADATA => initial_md,
+      CallOps::SEND_CLOSE_FROM_CLIENT => nil)
+    expect(client_batch.send_metadata).to be true
+    expect(client_batch.send_close).to be true
 
     # confirm the server can receive the client metadata
     rcv_thread.join
@@ -535,6 +623,24 @@ describe 'the secure http client/server' do
     recvd_md = recvd_rpc.metadata
     replace_symbols = Hash[expected_md.each_pair.collect { |x, y| [x.to_s, y] }]
     expect(recvd_md).to eq(recvd_md.merge(replace_symbols))
+
+    credentials_update_test_finish_call(call, recvd_rpc.call)
+  end
+
+  def credentials_update_test_finish_call(client_call, server_call)
+    final_server_batch = server_call.run_batch(
+      CallOps::RECV_CLOSE_ON_SERVER => nil,
+      CallOps::SEND_INITIAL_METADATA => nil,
+      CallOps::SEND_STATUS_FROM_SERVER => ok_status)
+    expect(final_server_batch.send_close).to be(true)
+    expect(final_server_batch.send_metadata).to be(true)
+    expect(final_server_batch.send_status).to be(true)
+
+    final_client_batch = client_call.run_batch(
+      CallOps::RECV_INITIAL_METADATA => nil,
+      CallOps::RECV_STATUS_ON_CLIENT => nil)
+    expect(final_client_batch.metadata).to eq({})
+    expect(final_client_batch.status.code).to eq(0)
   end
 
   it 'modifies metadata with CallCredentials' do