grpc 1.27.0.pre1-universal-darwin → 1.30.0.pre1-universal-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4f4232bcaa213aae2c70efbdc6f31d2bdb9d4725909d8412dfbc544dd23c9f3
-  data.tar.gz: f1a61c194ff783e29b46fac2906ac53cd3a6a23c8f8f811b32f845a6ef75f5a6
+  metadata.gz: 5eba0b2e80122fe383c0238b485d0944c7a0803b5a70b6af58882bc475347463
+  data.tar.gz: f4e6faae39b45e5eafde46f6338a6ddbe3f7957e1f9f2b17f459f840e2d359e8
 SHA512:
-  metadata.gz: b74ead153c1fa7498a0f5707306e1eaa6f4da01c93c92fe83108d78e9fcbafa184ec94c4a60668a044e2c10b96a53b6fb17824b06efddefd852542591040d8a3
-  data.tar.gz: e53e4677235ff22c11173ae9ea909fc2d7a040b0fae5248bccb1d20e07675026219ae93eabe71d2941226b86b02aa7a341d0594d04201ecaddb49cb7c4592e58
+  metadata.gz: 815b0b9c427776584013d4ae56e1518198fbc731965e452a320fbfb202bb64ac6bf3d4c776ab6923d8aa46592d79229a85f1e83c52e049daf23c68bda08fe189
+  data.tar.gz: a6d4bc3abac9f1cadf62b579cf11155d99a97dd009c5bbbc323d00e91b27d7c6158c13cc250512dc2a7f6761888d08219490e07b4eba7de368d57362b560fd66

data/src/ruby/ext/grpc/rb_call.c

@@ -620,6 +620,7 @@ typedef struct run_batch_stack {
   int recv_cancelled;
   grpc_status_code recv_status;
   grpc_slice recv_status_details;
+  const char* recv_status_debug_error_string;
   unsigned write_flag;
   grpc_slice send_status_details;
 } run_batch_stack;
@@ -729,6 +730,8 @@ static void grpc_run_batch_stack_fill_ops(run_batch_stack* st, VALUE ops_hash) {
             &st->recv_status;
         st->ops[st->op_num].data.recv_status_on_client.status_details =
             &st->recv_status_details;
+        st->ops[st->op_num].data.recv_status_on_client.error_string =
+            &st->recv_status_debug_error_string;
         break;
       case GRPC_OP_RECV_CLOSE_ON_SERVER:
         st->ops[st->op_num].data.recv_close_on_server.cancelled =
@@ -780,7 +783,12 @@ static VALUE grpc_run_batch_stack_build_result(run_batch_stack* st) {
                 (GRPC_SLICE_START_PTR(st->recv_status_details) == NULL
                      ? Qnil
                      : grpc_rb_slice_to_ruby_string(st->recv_status_details)),
-                grpc_rb_md_ary_to_h(&st->recv_trailing_metadata), NULL));
+                grpc_rb_md_ary_to_h(&st->recv_trailing_metadata),
+                st->recv_status_debug_error_string == NULL
+                    ? Qnil
+                    : rb_str_new_cstr(st->recv_status_debug_error_string),
+                NULL));
+        gpr_free((void*)st->recv_status_debug_error_string);
         break;
       case GRPC_OP_RECV_CLOSE_ON_SERVER:
         rb_struct_aset(result, sym_send_close, Qtrue);

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

@@ -30,18 +30,26 @@ module GRPC
   # https://github.com/grpc/grpc/blob/master/include/grpc/impl/codegen/status.h
   # for detailed descriptions of each status code.
   class BadStatus < StandardError
-    attr_reader :code, :details, :metadata
+    attr_reader :code, :details, :metadata, :debug_error_string
 
     include GRPC::Core::StatusCodes
 
     # @param code [Numeric] the status code
     # @param details [String] the details of the exception
     # @param metadata [Hash] the error's metadata
-    def initialize(code, details = 'unknown cause', metadata = {})
-      super("#{code}:#{details}")
+    def initialize(code,
+                   details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      exception_message = "#{code}:#{details}"
+      if debug_error_string
+        exception_message += ". debug_error_string:#{debug_error_string}"
+      end
+      super(exception_message)
       @code = code
       @details = details
       @metadata = metadata
+      @debug_error_string = debug_error_string
     end
 
     # Converts the exception to a {Struct::Status} for use in the networking
@@ -49,7 +57,7 @@ module GRPC
     #
     # @return [Struct::Status] with the same code and details
     def to_status
-      Struct::Status.new(code, details, metadata)
+      Struct::Status.new(code, details, metadata, debug_error_string)
     end
 
     # Converts the exception to a deserialized {Google::Rpc::Status} object.
@@ -66,8 +74,10 @@ module GRPC
       nil
     end
 
-    def self.new_status_exception(code, details = 'unknown cause',
-                                  metadata = {})
+    def self.new_status_exception(code,
+                                  details = 'unknown cause',
+                                  metadata = {},
+                                  debug_error_string = nil)
       codes = {}
       codes[OK] = Ok
       codes[CANCELLED] = Cancelled
@@ -88,129 +98,180 @@ module GRPC
       codes[DATA_LOSS] = DataLoss
 
       if codes[code].nil?
-        BadStatus.new(code, details, metadata)
+        BadStatus.new(code, details, metadata, debug_error_string)
       else
-        codes[code].new(details, metadata)
+        codes[code].new(details, metadata, debug_error_string)
       end
     end
   end
 
   # GRPC status code corresponding to status OK
   class Ok < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::OK, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::OK,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status CANCELLED
   class Cancelled < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::CANCELLED, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::CANCELLED,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status UNKNOWN
   class Unknown < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::UNKNOWN, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::UNKNOWN,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status INVALID_ARGUMENT
   class InvalidArgument < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::INVALID_ARGUMENT, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::INVALID_ARGUMENT,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status DEADLINE_EXCEEDED
   class DeadlineExceeded < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::DEADLINE_EXCEEDED, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::DEADLINE_EXCEEDED,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status NOT_FOUND
   class NotFound < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::NOT_FOUND, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::NOT_FOUND,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status ALREADY_EXISTS
   class AlreadyExists < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::ALREADY_EXISTS, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::ALREADY_EXISTS,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status PERMISSION_DENIED
   class PermissionDenied < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::PERMISSION_DENIED, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::PERMISSION_DENIED,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status UNAUTHENTICATED
   class Unauthenticated < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::UNAUTHENTICATED, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::UNAUTHENTICATED,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status RESOURCE_EXHAUSTED
   class ResourceExhausted < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::RESOURCE_EXHAUSTED, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::RESOURCE_EXHAUSTED,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status FAILED_PRECONDITION
   class FailedPrecondition < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::FAILED_PRECONDITION, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::FAILED_PRECONDITION,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status ABORTED
   class Aborted < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::ABORTED, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::ABORTED,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status OUT_OF_RANGE
   class OutOfRange < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::OUT_OF_RANGE, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::OUT_OF_RANGE,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status UNIMPLEMENTED
   class Unimplemented < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::UNIMPLEMENTED, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::UNIMPLEMENTED,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status INTERNAL
   class Internal < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::INTERNAL, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::INTERNAL,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status UNAVAILABLE
   class Unavailable < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::UNAVAILABLE, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::UNAVAILABLE,
+            details, metadata, debug_error_string)
     end
   end
 
   # GRPC status code corresponding to status DATA_LOSS
   class DataLoss < BadStatus
-    def initialize(details = 'unknown cause', metadata = {})
-      super(Core::StatusCodes::DATA_LOSS, details, metadata)
+    def initialize(details = 'unknown cause',
+                   metadata = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::DATA_LOSS,
+            details, metadata, debug_error_string)
     end
   end
 end

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)

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.27.0.pre1'
+  VERSION = '1.30.0.pre1'
 end