smithy-client 1.0.0.pre0 → 1.0.0.pre1

data/lib/smithy-client/plugins/http_api_key_auth.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../http_api_key_provider'
+require_relative '../identities/http_api_key'
+require_relative '../signers/http_api_key'
+require_relative '../auth_schemes/http_api_key'
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class HttpApiKeyAuth < Plugin
+        option(
+          :http_api_key,
+          doc_type: String,
+          docstring: 'The API key to use for authentication.'
+        ) do |config|
+          'stubbed-api-key' if config.stub_responses
+        end
+
+        option(
+          :http_api_key_provider,
+          doc_type: HttpApiKeyProvider,
+          docstring: <<~DOCS) do |config|
+            An API key identity provider. This can be an instance of a {Smithy::Client::HttpApiKeyProvider} or any
+            class that responds to #identity(properties) and returns a {Smithy::Client::Identities::HttpApiKey}.
+          DOCS
+          HttpApiKeyProvider.new(config.http_api_key) if config.http_api_key
+        end
+
+        option(:http_api_key_auth_scheme) do |_config|
+          Smithy::Client::AuthSchemes::HttpApiKey.new
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/http_basic_auth.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../http_login_provider'
+require_relative '../identities/http_login'
+require_relative '../signers/http_basic'
+require_relative '../auth_schemes/http_basic'
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class HttpBasicAuth < Plugin
+        option(
+          :http_login_username,
+          doc_type: String,
+          docstring: 'The username to use for authentication.'
+        ) do |config|
+          'stubbed-username' if config.stub_responses
+        end
+
+        option(
+          :http_login_password,
+          doc_type: String,
+          docstring: 'The password to use for authentication.'
+        ) do |config|
+          'stubbed-password' if config.stub_responses
+        end
+
+        option(
+          :http_login_provider,
+          doc_type: Smithy::Client::HttpLoginProvider,
+          docstring: <<~DOCS) do |config|
+            A login identity provider. This can be an instance of a {Smithy::Client::HttpLoginProvider} or any
+            class that responds to #identity(properties) and returns a {Smithy::Client::Identities::HttpLogin}.
+          DOCS
+          if config.http_login_username && config.http_login_password
+            Smithy::Client::HttpLoginProvider.new(config.http_login_username, config.http_login_password)
+          end
+        end
+
+        option(:http_basic_auth_scheme) do |_config|
+          Smithy::Client::AuthSchemes::HttpBasic.new
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/http_bearer_auth.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../http_bearer_provider'
+require_relative '../identities/http_bearer'
+require_relative '../signers/http_bearer'
+require_relative '../auth_schemes/http_bearer'
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class HttpBearerAuth < Plugin
+        option(
+          :http_bearer_token,
+          doc_type: String,
+          docstring: 'The bearer token to use for authentication.'
+        ) do |config|
+          'stubbed-bearer-token' if config.stub_responses
+        end
+
+        option(
+          :http_bearer_provider,
+          doc_type: Smithy::Client::HttpBearerProvider,
+          docstring: <<~DOCS) do |config|
+            A bearer token identity provider. This can be an instance of a {Smithy::Client::HttpBearerProvider} or any
+            class that responds to #identity(properties) and returns a {Smithy::Client::Identities::HttpBearer}.
+          DOCS
+          Smithy::Client::HttpBearerProvider.new(config.http_bearer_token) if config.http_bearer_token
+        end
+
+        option(:http_bearer_auth_scheme) do |_config|
+          Smithy::Client::AuthSchemes::HttpBearer.new
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/http_digest_auth.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../http_login_provider'
+require_relative '../identities/http_login'
+require_relative '../signers/http_digest'
+require_relative '../auth_schemes/http_digest'
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class HttpDigestAuth < Plugin
+        option(
+          :http_login_username,
+          doc_type: String,
+          docstring: 'The username to use for authentication.'
+        ) do |config|
+          'stubbed-username' if config.stub_responses
+        end
+
+        option(
+          :http_login_password,
+          doc_type: String,
+          docstring: 'The password to use for authentication.'
+        ) do |config|
+          'stubbed-password' if config.stub_responses
+        end
+
+        option(
+          :http_login_identity,
+          doc_type: Identities::HttpLogin,
+          docstring: 'The login identity to use for authentication.'
+        ) do |config|
+          if config.http_login_username && config.http_login_password
+            Identities::HttpLogin.new(
+              username: config.http_login_username,
+              password: config.http_login_password
+            )
+          end
+        end
+
+        option(
+          :http_login_provider,
+          doc_type: Smithy::Client::HttpLoginProvider,
+          docstring: <<~DOCS) do |config|
+            A login identity provider. This can be an instance of a {Smithy::Client::HttpLoginProvider} or any
+            class that responds to #identity(properties) and returns a {Smithy::Client::Identities::HttpLogin}.
+          DOCS
+          if config.http_login_username && config.http_login_password
+            Smithy::Client::HttpLoginProvider.new(config.http_login_username, config.http_login_password)
+          end
+        end
+
+        option(:http_digest_auth_scheme) do |_config|
+          Smithy::Client::AuthSchemes::HttpDigest.new
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/idempotency_token.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class IdempotencyToken < Plugin
+        def add_handlers(handlers, _config)
+          handlers.add(Handler, step: :initialize)
+        end
+
+        # @api private
+        class Handler < Client::Handler
+          def call(context)
+            apply_idempotency_token(context.operation.input, context.params)
+            @handler.call(context)
+          end
+
+          private
+
+          def apply_idempotency_token(input, params)
+            input.shape.members.each do |member_name, member_ref|
+              next unless member_ref.traits.key?('smithy.api#idempotencyToken')
+
+              params[member_name] ||= SecureRandom.uuid
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/logging.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class Logging < Plugin
+        option(
+          :logger,
+          default: nil,
+          doc_type: Logger,
+          docstring: 'The Logger instance to send log messages to. If this option is not set, logging is disabled.'
+        )
+
+        option(
+          :log_level,
+          default: :info,
+          doc_type: Symbol,
+          docstring: 'The log level to send messages to the logger at.'
+        )
+
+        option(
+          :log_formatter,
+          doc_type: 'Smithy::Client::LogFormatter',
+          doc_default: 'Aws::Log::Formatter.default',
+          docstring: 'The log formatter used by the logger.'
+        ) do |config|
+          LogFormatter.default if config.logger
+        end
+
+        def add_handlers(handlers, config)
+          handlers.add(Handler, step: :validate) if config.logger
+        end
+
+        # @api private
+        class Handler < Client::Handler
+          def call(context)
+            context[:logging_started_at] = Time.now
+            response = @handler.call(context)
+            context[:logging_completed_at] = Time.now
+            log(context.config, response)
+            response
+          end
+
+          private
+
+          def log(config, response)
+            config.logger.send(config.log_level, config.log_formatter.format(response))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/net_http.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative '../net_http/handler'
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class NetHTTP < Plugin
+        ## Connections
+
+        option(
+          :http_continue_timeout,
+          default: nil,
+          doc_type: Numeric,
+          docstring: <<~DOCS)
+            Sets the continue timeout value, which is the number of seconds to wait for an
+            expected 100 Continue response. If the HTTP object does not receive a response
+            in this many seconds it sends the request body. Defaults to `nil` which uses the
+            Net::HTTP default value.
+            See {https://docs.ruby-lang.org/en/master/Net/HTTP.html#attribute-i-continue_timeout Net::HTTP#continue_timeout}.
+          DOCS
+
+        option(
+          :http_keep_alive_timeout,
+          default: nil,
+          doc_type: Numeric,
+          docstring: <<~DOCS)
+            The number of seconds to keep the connection open after a request is sent. If a
+            new request is made during the given interval, the still-open connection is used;
+            otherwise the connection will have been closed and a new connection is opened.
+            Defaults to `nil` which uses the Net::HTTP default value.
+            See {https://docs.ruby-lang.org/en/master/Net/HTTP.html#attribute-i-keep_alive_timeout Net::HTTP#keep_alive_timeout}.
+          DOCS
+
+        option(
+          :http_open_timeout,
+          default: nil,
+          doc_type: Numeric,
+          docstring: <<~DOCS)
+            The number of seconds to wait for a connection to open. If the connection is not
+            made in the given interval, an exception is raised. Defaults to `nil` which uses
+            the Net::HTTP default value.
+            See {https://docs.ruby-lang.org/en/master/Net/HTTP.html#attribute-i-open_timeout Net::HTTP#open_timeout}.
+          DOCS
+
+        option(
+          :http_read_timeout,
+          default: nil,
+          doc_type: Numeric,
+          docstring: <<~DOCS)
+            The number of seconds to wait for one block to be read (via one read(2) call).
+            Defaults to `nil` which uses the Net::HTTP default value.
+            See {https://docs.ruby-lang.org/en/master/Net/HTTP.html#attribute-i-read_timeout Net::HTTP#read_timeout}.
+          DOCS
+
+        option(
+          :http_ssl_timeout,
+          default: nil,
+          doc_type: Numeric,
+          docstring: <<~DOCS)
+            Sets the SSL timeout seconds. Defaults to `nil` which uses the Net::HTTP default value.
+            See {https://docs.ruby-lang.org/en/master/Net/HTTP.html#attribute-i-ssl_timeout Net::HTTP#ssl_timeout}.
+          DOCS
+
+        option(
+          :http_write_timeout,
+          default: nil,
+          doc_type: Numeric,
+          docstring: <<~DOCS)
+            The number of seconds to wait for one block to be written (via one write(2) call).
+            Defaults to `nil` which uses the Net::HTTP default value.
+            See {https://docs.ruby-lang.org/en/master/Net/HTTP.html#attribute-i-write_timeout Net::HTTP#write_timeout}.
+          DOCS
+
+        ## Security
+
+        option(
+          :http_ca_file,
+          default: nil,
+          doc_type: String,
+          docstring: <<~DOCS)
+            The path to a CA certification file in PEM format. Defaults to `nil` which uses
+            the Net::HTTP default value.
+            See {https://docs.ruby-lang.org/en/master/Net/HTTP.html#attribute-i-ca_file Net::HTTP#ca_file}.
+          DOCS
+
+        option(
+          :http_ca_path,
+          default: nil,
+          doc_type: String,
+          docstring: <<~DOCS)
+            The path of to CA directory containing certification files in PEM format. Defaults to
+            `nil` which uses the Net::HTTP default value.
+            See {https://docs.ruby-lang.org/en/master/Net/HTTP.html#attribute-i-ca_path Net::HTTP#ca_path}.
+          DOCS
+
+        option(
+          :http_cert,
+          default: nil,
+          doc_type: OpenSSL::X509::Certificate,
+          docstring: <<~DOCS)
+            Sets the OpenSSL::X509::Certificate object to be used for client certification. Defaults
+            to `nil` which uses the Net::HTTP default value.
+            See {https://docs.ruby-lang.org/en/master/Net/HTTP.html#attribute-i-cert Net::HTTP#cert}.
+          DOCS
+
+        option(
+          :http_cert_store,
+          default: nil,
+          doc_type: OpenSSL::X509::Store,
+          docstring: <<~DOCS)
+            Sets the OpenSSL::X509::Store to be used for verifying peer certificate. Defaults to
+            `nil` which uses the Net::HTTP default value.
+            See {https://docs.ruby-lang.org/en/master/Net/HTTP.html#attribute-i-cert_store Net::HTTP#cert_store}.
+          DOCS
+
+        option(
+          :http_key,
+          default: nil,
+          doc_type: 'OpenSSL::PKey::RSA, OpenSSL::PKey::DSA',
+          docstring: <<~DOCS)
+            Sets the OpenSSL::PKey object to be used for client private key. Defaults to `nil` which
+            uses the Net::HTTP default value.
+            See {https://docs.ruby-lang.org/en/master/Net/HTTP.html#attribute-i-key Net::HTTP#key}.
+          DOCS
+
+        option(
+          :http_verify_mode,
+          default: OpenSSL::SSL::VERIFY_PEER,
+          doc_type: Integer,
+          doc_default: 'OpenSSL::SSL::VERIFY_PEER',
+          docstring: <<~DOCS)
+            Sets the verify mode for SSL. Defaults to `OpenSSL::SSL::VERIFY_PEER`.
+            See {https://docs.ruby-lang.org/en/master/Net/HTTP.html#attribute-i-verify_mode Net::HTTP#verify_mode}.
+          DOCS
+
+        ## Debugging
+
+        option(
+          :http_debug_output,
+          default: false,
+          doc_type: 'Boolean',
+          docstring: <<~DOCS)
+            When `true`, Net::HTTP debug output will be sent to the configured logger.
+            See {https://docs.ruby-lang.org/en/master/Net/HTTP.html#method-i-set_debug_output Net::HTTP#set_debug_output}.
+          DOCS
+
+        ## Proxies
+
+        option(
+          :http_proxy,
+          default: nil,
+          doc_type: 'URI::HTTP, String',
+          docstring: <<~DOCS)
+            A proxy to send requests through. Formatted like 'http://proxy.com:123'.
+          DOCS
+
+        handler(Client::NetHTTP::Handler, step: :send)
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/pageable_response.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class PageableResponse < Plugin
+        # @api private
+        class Handler < Client::Handler
+          def call(context)
+            response = @handler.call(context)
+            response.extend(Client::PageableResponse)
+            response.paginator = context.operation[:paginator] || NullPaginator.new
+            response
+          end
+
+          # @api private
+          class NullPaginator
+            def next_tokens(_data)
+              {}
+            end
+
+            def prev_tokens(_params)
+              {}
+            end
+
+            def items(_data)
+              raise NotImplementedError, 'item iteration is not implemented for this operation'
+            end
+          end
+        end
+
+        handler(Handler, step: :initialize, priority: 95)
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/param_converter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class ParamConverter < Plugin
+        option(
+          :convert_params,
+          default: true,
+          doc_type: 'Boolean',
+          docstring: <<~DOCS)
+            When `true`, request parameters are coerced into the required types.
+          DOCS
+
+        def add_handlers(handlers, config)
+          handlers.add(Handler, step: :initialize) if config.convert_params
+        end
+
+        # @api private
+        class Handler < Client::Handler
+          def call(context)
+            converter = Client::ParamConverter.new(context.operation.input)
+            context.params = converter.convert(context.params)
+            context.http_response.on_done { converter.close_opened_files }
+            @handler.call(context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/param_validator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class ParamValidator < Plugin
+        option(
+          :validate_params,
+          default: true,
+          doc_type: 'Boolean',
+          docstring: <<~DOCS)
+            When `true`, request parameters are validated before sending the request.
+          DOCS
+
+        def add_handlers(handlers, config)
+          handlers.add(Handler, step: :validate) if config.validate_params
+        end
+
+        # @api private
+        class Handler < Client::Handler
+          def call(context)
+            Client::ParamValidator.new(context.operation.input).validate!(context.params)
+            @handler.call(context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/protocol.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class Protocol < Plugin
+        option(
+          :protocol,
+          doc_default: '<DEFAULT_PROTOCOL>',
+          doc_type: 'String, Class',
+          docstring: 'The protocol to use for request serialization and response deserialization.'
+        )
+
+        # @api private
+        class BuildHandler < Handler
+          def call(context)
+            context.config.protocol.build_request(context)
+            @handler.call(context)
+          end
+        end
+
+        # @api private
+        class ParseHandler < Handler
+          def call(context)
+            response = @handler.call(context)
+            response.error = context.config.protocol.parse_error(response) unless response.error
+            response.data = context.config.protocol.parse_data(response) unless response.error
+            response
+          end
+        end
+
+        def add_handlers(handlers, _config)
+          handlers.add(BuildHandler)
+          handlers.add(ParseHandler, step: :parse)
+        end
+
+        def before_initialize(client_class, options)
+          protocol = options[:protocol]
+          case protocol
+          when nil
+            resolve_default_protocol(client_class, options)
+          when String
+            protocol_class = client_class.protocols[protocol]
+            raise ArgumentError, "Unknown protocol: #{protocol}" unless protocol_class
+
+            options[:protocol] = protocol_class.new
+          else
+            options[:protocol] = protocol
+          end
+        end
+
+        private
+
+        def resolve_default_protocol(client_class, options)
+          protocol_class = client_class.protocols.values.first
+          if protocol_class
+            options[:protocol] = protocol_class.new
+          elsif options[:stub_responses]
+            options[:protocol] = Stubbing::Protocol.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/raise_response_errors.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class RaiseResponseErrors < Plugin
+        option(
+          :raise_response_errors,
+          default: true,
+          doc_type: 'Boolean',
+          docstring: <<~DOCS)
+            When `true`, response errors are raised. When `false`, the error is placed on the
+            output in the {Smithy::Client::Response#error error accessor}.
+          DOCS
+
+        # @api private
+        class Handler < Client::Handler
+          def call(context)
+            response = @handler.call(context)
+            raise response.error if response.error
+
+            response
+          end
+        end
+
+        def add_handlers(handlers, config)
+          handlers.add(Handler, step: :validate, priority: 95) if config.raise_response_errors
+        end
+      end
+    end
+  end
+end