Remove Errors namespace under Smithy::Client (#299)

Author: mullermp

gems/smithy-client/lib/smithy-client.rb

@@ -11,8 +11,8 @@
 
 require_relative 'smithy-client/block_io'
 require_relative 'smithy-client/configuration'
+require_relative 'smithy-client/dynamic_errors'
 require_relative 'smithy-client/endpoint_rules'
-require_relative 'smithy-client/errors'
 require_relative 'smithy-client/handler'
 require_relative 'smithy-client/handler_builder'
 require_relative 'smithy-client/handler_context'
@@ -26,6 +26,7 @@
 require_relative 'smithy-client/plugin'
 require_relative 'smithy-client/plugin_list'
 require_relative 'smithy-client/retry'
+require_relative 'smithy-client/service_error'
 require_relative 'smithy-client/util'
 require_relative 'smithy-client/input'
 require_relative 'smithy-client/output'

gems/smithy-client/lib/smithy-client/dynamic_errors.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # This module is mixed into another module, providing dynamic
+    # error classes. Error classes all inherit from {ServiceError}.
+    #
+    #     # Creates and returns the class
+    #     Weather::Errors::MyNewErrorClass
+    #
+    # Since the complete list of possible errors returned by services may
+    # not be known, this allows us to create them as needed. This also
+    # allows users to rescue errors by class without them being concrete
+    # classes beforehand.
+    #
+    # @api private
+    module DynamicErrors
+      def self.extended(submodule)
+        submodule.instance_variable_set('@const_set_mutex', Mutex.new)
+        submodule.const_set(:ServiceError, Class.new(ServiceError))
+      end
+
+      def const_missing(constant)
+        set_error_constant(constant)
+      end
+
+      # Given the name of a service and an error code, this method
+      # returns an error class that extends {ServiceError}.
+      #
+      #     Weather::Errors.error_class('NoSuchCity').new
+      #     #=> #<Weather::Errors::NoSuchCity>
+      #
+      # @api private
+      def error_class(error_code)
+        constant = error_class_constant(error_code)
+        if error_const_set?(constant)
+          err_class = const_get(constant)
+          err_class.code = constant.to_s
+          err_class
+        else
+          set_error_constant(constant)
+        end
+      end
+
+      private
+
+      # Convert an error code to an error class name/constant.
+      # This requires filtering non-safe characters from the constant
+      # name and ensuring it begins with an uppercase letter.
+      #
+      # @param [String] error_code
+      # @return [Symbol] Returns a symbolized constant name for the given `error_code`.
+      def error_class_constant(error_code)
+        constant = error_code.to_s
+        constant = constant.gsub(/https?:.*$/, '')
+        constant = constant.gsub(/[^a-zA-Z0-9]/, '')
+        constant = "Error#{constant}" unless constant.match(/^[a-z]/i)
+        constant = constant[0].upcase + constant[1..]
+        constant.to_sym
+      end
+
+      def set_error_constant(constant) # rubocop:disable Naming/AccessorMethodName
+        @const_set_mutex.synchronize do
+          # Ensure the const was not defined while blocked by the mutex
+          if error_const_set?(constant)
+            const_get(constant)
+          else
+            error_class = Class.new(const_get(:ServiceError))
+            error_class.code = constant.to_s
+            const_set(constant, error_class)
+          end
+        end
+      end
+
+      def error_const_set?(constant)
+        # Purposefully not using #const_defined? as that method returns true
+        # for constants not defined directly in the current module.
+        constants.include?(constant.to_sym)
+      end
+    end
+  end
+end

gems/smithy-client/lib/smithy-client/errors.rb

@@ -62,7 +62,7 @@ def client?
         end
 
         def modeled_retryable?
-          @error.is_a?(Errors::ServiceError) && @error.retryable?
+          @error.is_a?(ServiceError) && @error.retryable?
         end
 
         def modeled_throttling?

gems/smithy-client/lib/smithy-client/http/error_inspector.rb

@@ -2,6 +2,20 @@
 
 module Smithy
   module Client
+    # Raised when calling {PageableOutput#next_page} on a paginator that
+    # is on the last page of results. You can call {PageableOutput#last_page?}
+    # or {PageableOutput#next_page?} to know if there are more pages.
+    class LastPageError < RuntimeError
+      # @param [Output] output
+      def initialize(output)
+        @output = output
+        super('unable to fetch next page, end of results reached')
+      end
+
+      # @return [Output]
+      attr_reader :output
+    end
+
     # Decorates a {Smithy::Client::Output} with paging convenience methods.
     # Most API calls provide paged responses to limit the amount of data returned
     # with each response. To optimize for latency, some APIs may return an
@@ -75,7 +89,7 @@ def next_page?
       # @param [Hash] params A hash of additional request params.
       # @return [Output] Returns the next page of results.
       def next_page(params = {})
-        raise Errors::LastPageError, self if last_page?
+        raise LastPageError, self if last_page?
 
         params = next_page_params(params)
         context.client.send(context.operation_name, params)

gems/smithy-client/lib/smithy-client/pageable_output.rb

@@ -8,8 +8,6 @@ class SignRequests < Plugin
         # @api private
         class Handler < Client::Handler
           def call(context)
-            # TODO: AWS specific - put this in properties
-            context[:auth].signer_properties['region'] = 'us-west-2'
             context[:auth].signer.sign(
               request: context.request,
               identity: context[:auth].identity,

gems/smithy-client/lib/smithy-client/plugins/sign_requests.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # The base class for all errors returned by a Smithy generated client.
+    # All ~400 level client errors and ~500 level server errors are raised
+    # as service errors. This indicates it was an error returned from the
+    # service and not one generated by the client.
+    class ServiceError < RuntimeError
+      # @param [Smithy::Client::HandlerContext] context
+      # @param [String] message
+      # @param [Structure] data
+      def initialize(context, message, data)
+        @code = self.class.code
+        @context = context
+        @message = extract_message(message, data)
+        @data = data
+        super(@message)
+      end
+
+      # @return [String, nil] The error code returned by the service.
+      attr_reader :code
+
+      # @return [Smithy::Client::HandlerContext] The context of the request
+      #  that triggered the remote service to return this error.
+      attr_reader :context
+
+      # @return [String] The error message returned by the service.
+      #  Defaults to the class name if no message is provided or can be parsed.
+      attr_reader :message
+
+      # @return [Structure] Additional data returned by the service.
+      attr_accessor :data
+
+      class << self
+        # @return [String, nil]
+        attr_accessor :code
+      end
+
+      # @return [Boolean] Returns `true` if the error is retryable.
+      def retryable?
+        false
+      end
+
+      # @return [Boolean] Returns `true` if the error is due to throttling.
+      def throttling?
+        false
+      end
+
+      private
+
+      def extract_message(message, data)
+        message || (data.message if data.respond_to?(:message)) || self.class.name.to_s
+      end
+    end
+  end
+end

gems/smithy-client/lib/smithy-client/service_error.rb

@@ -0,0 +1,15 @@
+module Smithy
+  module Client
+    class ServiceError < RuntimeError
+      def initialize: (HandlerContext?, String?, untyped?) -> void
+
+      attr_reader code: String?
+      attr_reader context: HandlerContext?
+      attr_reader message: String?
+      attr_accessor data: untyped?
+
+      def self.code: () -> String?
+      def self.code=: (String) -> void
+    end
+  end
+end