grpc 1.60.0.pre1-aarch64-linux

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

@@ -0,0 +1,169 @@
+/*
+ *
+ * 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.
+ *
+ */
+
+#include <ruby/ruby.h>
+
+#include "rb_xds_server_credentials.h"
+
+#include "rb_grpc.h"
+#include "rb_grpc_imports.generated.h"
+#include "rb_server_credentials.h"
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/log.h>
+
+/* grpc_rb_cXdsServerCredentials is the ruby class that proxies
+   grpc_server_credentials. */
+static VALUE grpc_rb_cXdsServerCredentials = Qnil;
+
+/* grpc_rb_xds_server_credentials wraps a grpc_server_credentials.  It provides
+   a peer ruby object, 'mark' to hold references to objects involved in
+   constructing the server credentials. */
+typedef struct grpc_rb_xds_server_credentials {
+  /* Holder of ruby objects involved in constructing the server credentials */
+  VALUE mark;
+  /* The actual server credentials */
+  grpc_server_credentials* wrapped;
+} grpc_rb_xds_server_credentials;
+
+/* Destroys the server credentials instances. */
+static void grpc_rb_xds_server_credentials_free_internal(void* p) {
+  grpc_rb_xds_server_credentials* wrapper = NULL;
+  if (p == NULL) {
+    return;
+  };
+  wrapper = (grpc_rb_xds_server_credentials*)p;
+
+  /* Delete the wrapped object if the mark object is Qnil, which indicates that
+     no other object is the actual owner. */
+  if (wrapper->wrapped != NULL && wrapper->mark == Qnil) {
+    grpc_server_credentials_release(wrapper->wrapped);
+    wrapper->wrapped = NULL;
+  }
+
+  xfree(p);
+}
+
+/* Destroys the server credentials instances. */
+static void grpc_rb_xds_server_credentials_free(void* p) {
+  grpc_rb_xds_server_credentials_free_internal(p);
+}
+
+/* Protects the mark object from GC */
+static void grpc_rb_xds_server_credentials_mark(void* p) {
+  if (p == NULL) {
+    return;
+  }
+  grpc_rb_xds_server_credentials* wrapper = (grpc_rb_xds_server_credentials*)p;
+
+  /* If it's not already cleaned up, mark the mark object */
+  if (wrapper->mark != Qnil) {
+    rb_gc_mark(wrapper->mark);
+  }
+}
+
+static const rb_data_type_t grpc_rb_xds_server_credentials_data_type = {
+    "grpc_xds_server_credentials",
+    {grpc_rb_xds_server_credentials_mark, grpc_rb_xds_server_credentials_free,
+     GRPC_RB_MEMSIZE_UNAVAILABLE, NULL},
+    NULL,
+    NULL,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
+/* Allocates ServerCredential instances.
+   Provides safe initial defaults for the instance fields. */
+static VALUE grpc_rb_xds_server_credentials_alloc(VALUE cls) {
+  grpc_ruby_init();
+  grpc_rb_xds_server_credentials* wrapper =
+      ALLOC(grpc_rb_xds_server_credentials);
+  wrapper->wrapped = NULL;
+  wrapper->mark = Qnil;
+  return TypedData_Wrap_Struct(cls, &grpc_rb_xds_server_credentials_data_type,
+                               wrapper);
+}
+
+/* The attribute used on the mark object to preserve the fallback_creds. */
+static ID id_fallback_creds;
+
+/*
+  call-seq:
+    creds = ServerCredentials.new(fallback_creds)
+    fallback_creds: (ServerCredentials) fallback credentials to create
+                    XDS credentials.
+    Initializes ServerCredential instances. */
+static VALUE grpc_rb_xds_server_credentials_init(VALUE self,
+                                                 VALUE fallback_creds) {
+  grpc_rb_xds_server_credentials* wrapper = NULL;
+  grpc_server_credentials* creds = NULL;
+
+  grpc_server_credentials* grpc_fallback_creds =
+      grpc_rb_get_wrapped_server_credentials(fallback_creds);
+  creds = grpc_xds_server_credentials_create(grpc_fallback_creds);
+
+  if (creds == NULL) {
+    rb_raise(rb_eRuntimeError,
+             "the call to grpc_xds_server_credentials_create() failed, could "
+             "not create a credentials, see "
+             "https://github.com/grpc/grpc/blob/master/TROUBLESHOOTING.md for "
+             "debugging tips");
+    return Qnil;
+  }
+  TypedData_Get_Struct(self, grpc_rb_xds_server_credentials,
+                       &grpc_rb_xds_server_credentials_data_type, wrapper);
+  wrapper->wrapped = creds;
+
+  /* Add the input objects as hidden fields to preserve them. */
+  rb_ivar_set(self, id_fallback_creds, fallback_creds);
+
+  return self;
+}
+
+void Init_grpc_xds_server_credentials() {
+  grpc_rb_cXdsServerCredentials = rb_define_class_under(
+      grpc_rb_mGrpcCore, "XdsServerCredentials", rb_cObject);
+
+  /* Allocates an object managed by the ruby runtime */
+  rb_define_alloc_func(grpc_rb_cXdsServerCredentials,
+                       grpc_rb_xds_server_credentials_alloc);
+
+  /* Provides a ruby constructor and support for dup/clone. */
+  rb_define_method(grpc_rb_cXdsServerCredentials, "initialize",
+                   grpc_rb_xds_server_credentials_init, 1);
+  rb_define_method(grpc_rb_cXdsServerCredentials, "initialize_copy",
+                   grpc_rb_cannot_init_copy, 1);
+
+  id_fallback_creds = rb_intern("__fallback_creds");
+}
+
+/* Gets the wrapped grpc_server_credentials from the ruby wrapper */
+grpc_server_credentials* grpc_rb_get_wrapped_xds_server_credentials(VALUE v) {
+  grpc_rb_xds_server_credentials* wrapper = NULL;
+  Check_TypedStruct(v, &grpc_rb_xds_server_credentials_data_type);
+  TypedData_Get_Struct(v, grpc_rb_xds_server_credentials,
+                       &grpc_rb_xds_server_credentials_data_type, wrapper);
+  return wrapper->wrapped;
+}
+
+/* Check if v is kind of ServerCredentials */
+bool grpc_rb_is_xds_server_credentials(VALUE v) {
+  return rb_typeddata_is_kind_of(v, &grpc_rb_xds_server_credentials_data_type);
+}

data/src/ruby/ext/grpc/rb_xds_server_credentials.h

@@ -0,0 +1,37 @@
+/*
+ *
+ * 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 <ruby/ruby.h>
+
+#include <stdbool.h>
+
+#include <grpc/grpc_security.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/core/status_codes.rb

@@ -0,0 +1,135 @@
+# 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.
+
+# GRPC contains the General RPC module.
+module GRPC
+  module Core
+    # StatusCodes defines the canonical error codes used by gRPC for the RPC
+    # API.
+    module StatusCodes
+      # OK is returned on success.
+      OK = 0
+
+      # Canceled indicates the operation was canceled (typically by the caller).
+      CANCELLED = 1
+
+      # Unknown error. An example of where this error may be returned is if a
+      # Status value received from another address space belongs to an
+      # error-space that is not known in this address space. Also errors raised
+      # by APIs that do not return enough error information may be converted to
+      # this error.
+      UNKNOWN = 2
+
+      # InvalidArgument indicates client specified an invalid argument. Note
+      # that this differs from FailedPrecondition. It indicates arguments that
+      # are problematic regardless of the state of the system (e.g., a malformed
+      # file name).
+      INVALID_ARGUMENT = 3
+
+      # DeadlineExceeded means operation expired before completion. For
+      # operations that change the state of the system, this error may be
+      # returned even if the operation has completed successfully. For example,
+      # a successful response from a server could have been delayed long enough
+      # for the deadline to expire.
+      DEADLINE_EXCEEDED = 4
+
+      # NotFound means some requested entity (e.g., file or directory) was not
+      # found.
+      NOT_FOUND = 5
+
+      # AlreadyExists means an attempt to create an entity failed because one
+      # already exists.
+      ALREADY_EXISTS = 6
+
+      # PermissionDenied indicates the caller does not have permission to
+      # execute the specified operation. It must not be used for rejections
+      # caused by exhausting some resource (use ResourceExhausted instead for
+      # those errors). It must not be used if the caller cannot be identified
+      # (use Unauthenticated instead for those errors).
+      PERMISSION_DENIED = 7
+
+      # ResourceExhausted indicates some resource has been exhausted, perhaps a
+      # per-user quota, or perhaps the entire file system is out of space.
+      RESOURCE_EXHAUSTED = 8
+
+      # FailedPrecondition indicates operation was rejected because the system
+      # is not in a state required for the operation's execution. For example,
+      # directory to be deleted may be non-empty, an rmdir operation is applied
+      # to a non-directory, etc.
+      #
+      # A litmus test that may help a service implementor in deciding between
+      # FailedPrecondition, Aborted, and Unavailable:
+      #  (a) Use Unavailable if the client can retry just the failing call.
+      #  (b) Use Aborted if the client should retry at a higher-level (e.g.,
+      #      restarting a read-modify-write sequence).
+      #  (c) Use FailedPrecondition if the client should not retry until the
+      #      system state has been explicitly fixed. E.g., if an "rmdir" fails
+      #      because the directory is non-empty, FailedPrecondition should be
+      #      returned since the client should not retry unless they have first
+      #      fixed up the directory by deleting files from it.
+      #  (d) Use FailedPrecondition if the client performs conditional REST
+      #      Get/Update/Delete on a resource and the resource on the server does
+      #      not match the condition. E.g., conflicting read-modify-write on the
+      #      same resource.
+      FAILED_PRECONDITION = 9
+
+      # Aborted indicates the operation was aborted, typically due to a
+      # concurrency issue like sequencer check failures, transaction aborts,
+      # etc.
+      #
+      # See litmus test above for deciding between FailedPrecondition, Aborted,
+      # and Unavailable.
+      ABORTED = 10
+
+      # OutOfRange means operation was attempted past the valid range. E.g.,
+      # seeking or reading past end of file.
+      #
+      # Unlike InvalidArgument, this error indicates a problem that may be fixed
+      # if the system state changes. For example, a 32-bit file system will
+      # generate InvalidArgument if asked to read at an offset that is not in
+      # the range [0,2^32-1], but it will generate OutOfRange if asked to read
+      # from an offset past the current file size.
+      #
+      # There is a fair bit of overlap between FailedPrecondition and
+      # OutOfRange. We recommend using OutOfRange (the more specific error) when
+      # it applies so that callers who are iterating through a space can easily
+      # look for an OutOfRange error to detect when they are done.
+      OUT_OF_RANGE = 11
+
+      # Unimplemented indicates operation is not implemented or not
+      # supported/enabled in this service.
+      UNIMPLEMENTED = 12
+
+      # Internal errors. Means some invariants expected by underlying system has
+      # been broken. If you see one of these errors, something is very broken.
+      INTERNAL = 13
+
+      # Unavailable indicates the service is currently unavailable. This is a
+      # most likely a transient condition and may be corrected by retrying with
+      # a backoff. Note that it is not always safe to retry non-idempotent
+      # operations.
+      #
+      # See litmus test above for deciding between FailedPrecondition, Aborted,
+      # and Unavailable.
+      UNAVAILABLE = 14
+
+      # DataLoss indicates unrecoverable data loss or corruption.
+      DATA_LOSS = 15
+
+      # Unauthenticated indicates the request does not have valid authentication
+      # credentials for the operation.
+      UNAUTHENTICATED = 16
+    end
+  end
+end

data/src/ruby/lib/grpc/core/time_consts.rb

@@ -0,0 +1,56 @@
+# 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_relative '../grpc'
+
+# GRPC contains the General RPC module.
+module GRPC
+  module Core
+    # TimeConsts is a module from the C extension.
+    #
+    # Here it's re-opened to add a utility func.
+    module TimeConsts
+      # Converts a time delta to an absolute deadline.
+      #
+      # Assumes timeish is a relative time, and converts its to an absolute,
+      # with following exceptions:
+      #
+      # * if timish is one of the TimeConsts.TimeSpec constants the value is
+      # preserved.
+      # * timish < 0 => TimeConsts.INFINITE_FUTURE
+      # * timish == 0 => TimeConsts.ZERO
+      #
+      # @param timeish [Number|TimeSpec]
+      # @return [Number|TimeSpec]
+      def from_relative_time(timeish)
+        if timeish.is_a? TimeSpec
+          timeish
+        elsif timeish.nil?
+          TimeConsts::ZERO
+        elsif !timeish.is_a? Numeric
+          fail(TypeError,
+               "Cannot make an absolute deadline from #{timeish.inspect}")
+        elsif timeish < 0
+          TimeConsts::INFINITE_FUTURE
+        elsif timeish.zero?
+          TimeConsts::ZERO
+        else
+          Time.now + timeish
+        end
+      end
+
+      module_function :from_relative_time
+    end
+  end
+end

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

@@ -0,0 +1,277 @@
+# 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_relative './structs'
+require_relative './core/status_codes'
+require_relative './google_rpc_status_utils'
+
+# GRPC contains the General RPC module.
+module GRPC
+  # BadStatus is an exception class that indicates that an error occurred at
+  # either end of a GRPC connection.  When raised, it indicates that a status
+  # error should be returned to the other end of a GRPC connection; when
+  # caught it means that this end received a status error.
+  #
+  # There is also subclass of BadStatus in this module for each GRPC status.
+  # E.g., the GRPC::Cancelled class corresponds to status CANCELLED.
+  #
+  # See
+  # 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, :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 = {},
+                   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
+    # wrapper layer.
+    #
+    # @return [Struct::Status] with the same code and details
+    def to_status
+      Struct::Status.new(code, details, metadata, debug_error_string)
+    end
+
+    # Converts the exception to a deserialized {Google::Rpc::Status} object.
+    # Returns `nil` if the `grpc-status-details-bin` trailer could not be
+    # converted to a {Google::Rpc::Status} due to the server not providing
+    # the necessary trailers.
+    #
+    # @return [Google::Rpc::Status, nil]
+    def to_rpc_status
+      GoogleRpcStatusUtils.extract_google_rpc_status(to_status)
+    rescue Google::Protobuf::ParseError => parse_error
+      GRPC.logger.warn('parse error: to_rpc_status failed')
+      GRPC.logger.warn(parse_error)
+      nil
+    end
+
+    def self.new_status_exception(code,
+                                  details = 'unknown cause',
+                                  metadata = {},
+                                  debug_error_string = nil)
+      codes = {}
+      codes[OK] = Ok
+      codes[CANCELLED] = Cancelled
+      codes[UNKNOWN] = Unknown
+      codes[INVALID_ARGUMENT] = InvalidArgument
+      codes[DEADLINE_EXCEEDED] = DeadlineExceeded
+      codes[NOT_FOUND] = NotFound
+      codes[ALREADY_EXISTS] = AlreadyExists
+      codes[PERMISSION_DENIED] = PermissionDenied
+      codes[UNAUTHENTICATED] = Unauthenticated
+      codes[RESOURCE_EXHAUSTED] = ResourceExhausted
+      codes[FAILED_PRECONDITION] = FailedPrecondition
+      codes[ABORTED] = Aborted
+      codes[OUT_OF_RANGE] = OutOfRange
+      codes[UNIMPLEMENTED] = Unimplemented
+      codes[INTERNAL] = Internal
+      codes[UNAVAILABLE] = Unavailable
+      codes[DATA_LOSS] = DataLoss
+
+      if codes[code].nil?
+        BadStatus.new(code, details, metadata, debug_error_string)
+      else
+        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 = {},
+                   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 = {},
+                   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 = {},
+                   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 = {},
+                   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 = {},
+                   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 = {},
+                   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 = {},
+                   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 = {},
+                   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 = {},
+                   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 = {},
+                   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 = {},
+                   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 = {},
+                   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 = {},
+                   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 = {},
+                   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 = {},
+                   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 = {},
+                   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 = {},
+                   debug_error_string = nil)
+      super(Core::StatusCodes::DATA_LOSS,
+            details, metadata, debug_error_string)
+    end
+  end
+end