istox_gruf 2.7.1

data/lib/gruf/client/error_factory.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2017-present, BigCommerce Pty. Ltd. All rights reserved
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+module Gruf
+  class Client < SimpleDelegator
+    ##
+    # Translates exceptions into Gruf::Client::Errors
+    #
+    class ErrorFactory
+      ##
+      # @param [Class] default_class
+      # @param [Class] deserializer_class
+      # @param [String|Symbol] metadata_key
+      #
+      def initialize(
+        default_class: nil,
+        deserializer_class: nil,
+        metadata_key: nil
+      )
+        @default_class = default_class || Gruf::Client::Errors::Internal
+        @metadata_key = (metadata_key || Gruf.error_metadata_key).to_s
+        @deserializer_class = deserializer_class || default_serializer
+      end
+
+      ##
+      # Determine the proper error class to raise given the incoming exception. This will attempt to coalesce the
+      # exception object into the appropriate Gruf::Client::Errors subclass, or fallback to the default class if none
+      # is found (or it is a StandardError or higher-level error). It will leave alone Signals instead of attempting to
+      # coalesce them.
+      #
+      # @param [Exception] exception
+      # @return [Gruf::Client::Errors::Base|SignalException]
+      #
+      def from_exception(exception)
+        # passthrough on Signals, we don't want to mess with these
+        return exception if exception.is_a?(SignalException)
+
+        exception_class = determine_class(exception)
+        if exception.is_a?(GRPC::BadStatus)
+          # if it's a GRPC::BadStatus code, let's check for any trailing error metadata and decode it
+          exception_class.new(deserialize(exception))
+        else
+          # otherwise, let's just capture the error and build the wrapper class
+          exception_class.new(exception)
+        end
+      end
+
+      private
+
+      ##
+      # Deserialize any trailing metadata error payload from the exception
+      #
+      # @param [Gruf::Client::Errors::Base]
+      # @return [String]
+      #
+      def deserialize(exception)
+        if exception.respond_to?(:metadata)
+          key = exception.metadata.key?(@metadata_key.to_s) ? @metadata_key.to_s : @metadata_key.to_sym
+          return @deserializer_class.new(exception.metadata[key]).deserialize if exception.metadata.key?(key)
+        end
+
+        exception
+      end
+
+      ##
+      # @param [Exception] exception
+      # @return [Gruf::Client::Errors::Base]
+      #
+      def determine_class(exception)
+        error_class = Gruf::Client::Errors.const_get(exception.class.name.demodulize)
+
+        # Ruby module inheritance will have StandardError, ScriptError, etc still get to this point
+        # So we need to explicitly check for ancestry here
+        return @default_class unless error_class.ancestors.include?(Gruf::Client::Errors::Base)
+
+        error_class
+      rescue NameError => _e
+        @default_class
+      end
+
+      ##
+      # @return [Gruf::Serializers::Errors::Base]
+      #
+      def default_serializer
+        return Gruf::Serializers::Errors::Json unless Gruf.error_serializer
+
+        Gruf.error_serializer.is_a?(Class) ? Gruf.error_serializer : Gruf.error_serializer.to_s.constantize
+      end
+    end
+  end
+end

data/lib/gruf/configuration.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2017-present, BigCommerce Pty. Ltd. All rights reserved
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+module Gruf
+  ##
+  # Represents configuration settings for the system
+  #
+  module Configuration
+    VALID_CONFIG_KEYS = {
+      root_path: '',
+      server_binding_url: '0.0.0.0:9001',
+      server_options: {},
+      interceptors: nil,
+      hooks: nil,
+      default_client_host: '',
+      use_ssl: false,
+      ssl_crt_file: '',
+      ssl_key_file: '',
+      controllers_path: '',
+      services: [],
+      logger: nil,
+      grpc_logger: nil,
+      error_metadata_key: :'error-internal-bin',
+      error_serializer: nil,
+      append_server_errors_to_trailing_metadata: true,
+      use_default_interceptors: true,
+      backtrace_on_error: false,
+      backtrace_limit: 10,
+      use_exception_message: true,
+      internal_error_message: 'Internal Server Error',
+      event_listener_proc: nil,
+      synchronized_client_internal_cache_expiry: 60,
+      rpc_server_options: {
+        pool_size: GRPC::RpcServer::DEFAULT_POOL_SIZE,
+        max_waiting_requests: GRPC::RpcServer::DEFAULT_MAX_WAITING_REQUESTS,
+        poll_period: GRPC::RpcServer::DEFAULT_POLL_PERIOD,
+        pool_keep_alive: GRPC::Pool::DEFAULT_KEEP_ALIVE,
+        connect_md_proc: nil,
+        server_args: {}
+      }.freeze
+    }.freeze
+
+    attr_accessor(* VALID_CONFIG_KEYS.keys)
+
+    ##
+    # Whenever this is extended into a class, setup the defaults
+    #
+    def self.extended(base)
+      if defined?(Rails)
+        Gruf::Integrations::Rails::Railtie.config.before_initialize { base.reset }
+      else
+        base.reset
+      end
+    end
+
+    ##
+    # Yield self for ruby-style initialization
+    #
+    # @yields [Gruf::Configuration] The configuration object for gruf
+    # @return [Gruf::Configuration] The configuration object for gruf
+    #
+    def configure
+      yield self
+    end
+
+    ##
+    # Return the current configuration options as a Hash
+    #
+    # @return [Hash] The configuration for gruf, represented as a Hash
+    #
+    def options
+      opts = {}
+      VALID_CONFIG_KEYS.each_key do |k|
+        opts.merge!(k => send(k))
+      end
+      opts
+    end
+
+    ##
+    # Set the default configuration onto the extended class
+    #
+    # @return [Hash] options The reset options hash
+    #
+    def reset
+      VALID_CONFIG_KEYS.each do |k, v|
+        send((k.to_s + '='), v)
+      end
+      self.interceptors = Gruf::Interceptors::Registry.new
+      self.hooks = Gruf::Hooks::Registry.new
+      self.root_path = Rails.root.to_s.chomp('/') if defined?(Rails)
+      if defined?(Rails) && Rails.logger
+        self.logger = Rails.logger
+      else
+        require 'logger'
+        self.logger = ::Logger.new(STDOUT)
+      end
+      self.grpc_logger = logger if grpc_logger.nil?
+      self.ssl_crt_file = "#{root_path}config/ssl/#{environment}.crt"
+      self.ssl_key_file = "#{root_path}config/ssl/#{environment}.key"
+      self.controllers_path = root_path.to_s.empty? ? 'app/rpc' : "#{root_path}/app/rpc"
+      if use_default_interceptors
+        interceptors.use(Gruf::Interceptors::ActiveRecord::ConnectionReset)
+        interceptors.use(Gruf::Interceptors::Instrumentation::OutputMetadataTimer)
+      end
+      options
+    end
+
+    private
+
+    ##
+    # Automatically determine environment
+    #
+    # @return [String] The current Ruby environment
+    #
+    def environment
+      if defined?(Rails)
+        Rails.env.to_s
+      else
+        (ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development').to_s
+      end
+    end
+  end
+end

data/lib/gruf/controllers/base.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2017-present, BigCommerce Pty. Ltd. All rights reserved
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+require_relative 'request'
+require_relative 'service_binder'
+
+module Gruf
+  module Controllers
+    ##
+    # Base controller object for Gruf gRPC requests
+    #
+    class Base
+      include Gruf::Errors::Helpers
+
+      # @var [Gruf::Controller::Request] request
+      attr_reader :request
+      # @var [Gruf::Error] error
+      attr_reader :error
+
+      class << self
+        # @var [GRPC::GenericService] bound_service
+        attr_reader :bound_service
+      end
+
+      ##
+      # Initialize the controller within the given request context
+      #
+      # @param [Symbol] method_key The gRPC method that this controller relates to
+      # @param [GRPC::GenericService] service The gRPC service stub for this controller
+      # @param [GRPC::RpcDesc] rpc_desc The RPC descriptor for this service method
+      # @param [GRPC::ActiveCall] active_call The gRPC ActiveCall object
+      # @param [Google::Protobuf::MessageExts] message The incoming protobuf request message
+      #
+      def initialize(method_key:, service:, rpc_desc:, active_call:, message:)
+        @request = Request.new(
+          method_key: method_key,
+          service: service,
+          rpc_desc: rpc_desc,
+          active_call: active_call,
+          message: message
+        )
+        @error = Gruf::Error.new
+        @interceptors = Gruf.interceptors.prepare(@request, @error)
+      end
+
+      ##
+      # Bind the controller to the given service and add it to the service registry
+      #
+      # @param [GRPC::GenericService] service The name of the service to bind this controller to
+      #
+      def self.bind(service)
+        service_class = service.name.constantize
+        Gruf.services << service_class
+        @bound_service = service_class
+        ServiceBinder.new(service_class).bind!(self)
+      end
+
+      ##
+      # Call a method on this controller.
+      # Override this in a subclass to modify the behavior around processing a method
+      #
+      # @param [Symbol] method_key The name of the gRPC service method being called as a Symbol
+      # @param [block] &block The passed block for executing the method
+      #
+      def process_action(method_key, &block)
+        send(method_key, &block)
+      end
+
+      ##
+      # Call a method on this controller
+      #
+      # @param [Symbol] method_key The name of the gRPC service method being called as a Symbol
+      # @param [block] &block The passed block for executing the method
+      #
+      def call(method_key, &block)
+        Interceptors::Context.new(@interceptors).intercept! do
+          process_action(method_key, &block)
+        end
+      rescue GRPC::BadStatus
+        raise # passthrough, to be caught by Gruf::Interceptors::Timer
+      rescue GRPC::Core::CallError, StandardError => e # CallError is not a StandardError
+        set_debug_info(e.message, e.backtrace) if Gruf.backtrace_on_error
+        error_message = Gruf.use_exception_message ? e.message : Gruf.internal_error_message
+        fail!(:internal, :unknown, error_message)
+      end
+    end
+  end
+end

data/lib/gruf/controllers/request.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2017-present, BigCommerce Pty. Ltd. All rights reserved
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+module Gruf
+  module Controllers
+    ##
+    # Encapsulates a request for a controller
+    #
+    class Request
+      # @var [Object] message
+      attr_reader :message
+      # @var [GRPC::ActiveCall] active_call
+      attr_reader :active_call
+      # @var [Symbol] method_key
+      attr_reader :method_key
+      # @var [Gruf::Controllers::Request::Type] type
+      attr_reader :type
+      # @var [Class] service
+      attr_reader :service
+
+      delegate :metadata, to: :active_call
+      delegate :messages, :client_streamer?, :server_streamer?, :bidi_streamer?, :request_response?, to: :type
+
+      ##
+      # Abstract representation of a gRPC request type
+      #
+      class Type
+        delegate :client_streamer?, :server_streamer?, :bidi_streamer?, :request_response?, to: :@rpc_desc
+
+        ##
+        # Initialize a new request type object
+        #
+        # @param [GRPC::RpcDesc] rpc_desc The RPC descriptor for the request type
+        #
+        def initialize(rpc_desc)
+          @rpc_desc = rpc_desc
+        end
+      end
+
+      ##
+      # Initialize an inbound controller request object
+      #
+      # @param [Symbol] method_key The method symbol of the RPC method being executed
+      # @param [Class] service The class of the service being executed against
+      # @param [GRPC::RpcDesc] rpc_desc The RPC descriptor of the call
+      # @param [GRPC::ActiveCall] active_call The restricted view of the call
+      # @param [Object] message The protobuf message (or messages) of the request
+      #
+      def initialize(method_key:, service:, rpc_desc:, active_call:, message:)
+        @method_key = method_key
+        @service = service
+        @active_call = active_call
+        @message = message
+        @rpc_desc = rpc_desc
+        @type = Type.new(rpc_desc)
+      end
+
+      ##
+      # Returns the service name as a translated name separated by periods. Strips
+      # the superfluous "Service" suffix from the name
+      #
+      # @return [String] The mapped service key
+      #
+      def service_key
+        @service.name.underscore.tr('/', '.').gsub('.service', '')
+      end
+
+      ##
+      # @return [Class] The class of the response message
+      #
+      def response_class
+        @rpc_desc.output
+      end
+
+      ##
+      # @return [Class] The class of the request message
+      #
+      def request_class
+        @rpc_desc.input
+      end
+
+      ##
+      # Parse the method signature into a service.method name format
+      #
+      # @return [String] The parsed service method name
+      #
+      def method_name
+        "#{service_key}.#{method_key}"
+      end
+
+      ##
+      # Return all messages for this request, properly handling different request types
+      #
+      # @return Enumerable<Object> All messages for this request
+      #
+      def messages
+        if client_streamer?
+          message.call { |msg| yield msg }
+        elsif bidi_streamer?
+          message
+        else
+          [message]
+        end
+      end
+    end
+  end
+end