aws-sdk-core 2.11.549

data/lib/seahorse/client/net_http/patches.rb

@@ -0,0 +1,98 @@
+require 'net/http'
+
+module Seahorse
+  module Client
+    module NetHttp
+
+      # @api private
+      module Patches
+
+        def self.apply!
+          if RUBY_VERSION >= '2.0'
+            Net::HTTP.send(:include, Ruby_2)
+            Net::HTTP::IDEMPOTENT_METHODS_.clear
+          elsif RUBY_VERSION >= '1.9.3'
+            Net::HTTP.send(:include, Ruby_1_9_3)
+          end
+          Net::HTTP.send(:alias_method, :old_transport_request, :transport_request)
+          Net::HTTP.send(:alias_method, :transport_request, :new_transport_request)
+        end
+
+        module Ruby_2
+          def new_transport_request(req)
+            count = 0
+            begin
+              begin_transport req
+              res = catch(:response) {
+                req.exec @socket, @curr_http_version, edit_path(req.path)
+                begin
+                  res = Net::HTTPResponse.read_new(@socket)
+                  res.decode_content = req.decode_content
+                end while res.kind_of?(Net::HTTPContinue)
+
+                res.uri = req.uri
+
+                res
+              }
+              res.reading_body(@socket, req.response_body_permitted?) {
+                yield res if block_given?
+              }
+            rescue Net::OpenTimeout
+              raise
+            rescue Net::ReadTimeout, IOError, EOFError,
+                   Errno::ECONNRESET, Errno::ECONNABORTED, Errno::EPIPE,
+                   # avoid a dependency on OpenSSL
+                   defined?(OpenSSL::SSL) ? OpenSSL::SSL::SSLError : IOError,
+                   Timeout::Error => exception
+              if count == 0 && Net::HTTP::IDEMPOTENT_METHODS_.include?(req.method)
+                count += 1
+                @socket.close if @socket and not @socket.closed?
+                D "Conn close because of error #{exception}, and retry"
+                if req.body_stream
+                  if req.body_stream.respond_to?(:rewind)
+                    req.body_stream.rewind
+                  else
+                    raise
+                  end
+                end
+                retry
+              end
+              D "Conn close because of error #{exception}"
+              @socket.close if @socket and not @socket.closed?
+              raise
+            end
+
+            end_transport req, res
+            res
+          rescue => exception
+            D "Conn close because of error #{exception}"
+            @socket.close if @socket and not @socket.closed?
+            raise exception
+          end
+        end
+
+        module Ruby_1_9_3
+          def new_transport_request(req)
+            begin_transport req
+            res = catch(:response) {
+              req.exec @socket, @curr_http_version, edit_path(req.path)
+              begin
+                res = Net::HTTPResponse.read_new(@socket)
+              end while res.kind_of?(Net::HTTPContinue)
+              res
+            }
+            res.reading_body(@socket, req.response_body_permitted?) {
+              yield res if block_given?
+            }
+            end_transport req, res
+            res
+          rescue => exception
+            D "Conn close because of error #{exception}"
+            @socket.close if @socket and not @socket.closed?
+            raise exception
+          end
+        end
+      end
+    end
+  end
+end

data/lib/seahorse/client/networking_error.rb

@@ -0,0 +1,15 @@
+module Seahorse
+  module Client
+    class NetworkingError < StandardError
+
+      def initialize(error, msg = nil)
+        super(msg || error.message)
+        set_backtrace(error.backtrace)
+        @original_error = error
+      end
+
+      attr_reader :original_error
+
+    end
+  end
+end

data/lib/seahorse/client/plugin.rb

@@ -0,0 +1,80 @@
+module Seahorse
+  module Client
+    class Plugin
+
+      extend HandlerBuilder
+
+      # @param [Configuration] config
+      # @return [void]
+      def add_options(config)
+        self.class.options.each do |args, block|
+          config.add_option(*args, &block)
+        end
+      end
+
+      # @param [HandlerList] handlers
+      # @param [Configuration] config
+      # @return [void]
+      def add_handlers(handlers, config)
+        handlers.copy_from(self.class.handlers)
+      end
+
+      # @param [Class<Client::Base>] client_class
+      # @param [Hash] options
+      # @return [void]
+      def before_initialize(client_class, options)
+        self.class.before_initialize_hooks.each do |block|
+          block.call(client_class, options)
+        end
+      end
+
+      # @param [Client::Base] client
+      # @return [void]
+      def after_initialize(client)
+        self.class.after_initialize_hooks.each do |block|
+          block.call(client)
+        end
+      end
+
+      class << self
+
+        def option(name, default = nil, &block)
+          if block_given?
+            options << [[name], block]
+          else
+            options << [[name, default]]
+          end
+        end
+
+        def before_initialize(&block)
+          before_initialize_hooks << block
+        end
+
+        def after_initialize(&block)
+          after_initialize_hooks << block
+        end
+
+        # @api private
+        def options
+          @options ||= []
+        end
+
+        # @api private
+        def handlers
+          @handlers ||= HandlerList.new
+        end
+
+        # @api private
+        def before_initialize_hooks
+          @before_initialize_hooks ||= []
+        end
+
+        # @api private
+        def after_initialize_hooks
+          @after_initialize_hooks ||= []
+        end
+
+      end
+    end
+  end
+end

data/lib/seahorse/client/plugin_list.rb

@@ -0,0 +1,144 @@
+require 'set'
+require 'thread'
+
+module Seahorse
+  module Client
+    class PluginList
+
+      include Enumerable
+
+      # @param [Array, Set] plugins
+      # @option options [Mutex] :mutex
+      def initialize(plugins = [], options = {})
+        @mutex = options[:mutex] || Mutex.new
+        @plugins = Set.new
+        if plugins.is_a?(PluginList)
+          plugins.send(:each_plugin) { |plugin| _add(plugin) }
+        else
+          plugins.each { |plugin| _add(plugin) }
+        end
+      end
+
+      # Adds and returns the `plugin`.
+      # @param [Plugin] plugin
+      # @return [void]
+      def add(plugin)
+        @mutex.synchronize do
+          _add(plugin)
+        end
+        nil
+      end
+
+      # Removes and returns the `plugin`.
+      # @param [Plugin] plugin
+      # @return [void]
+      def remove(plugin)
+        @mutex.synchronize do
+          @plugins.delete(PluginWrapper.new(plugin))
+        end
+        nil
+      end
+
+      # Replaces the existing list of plugins.
+      # @param [Array<Plugin>] plugins
+      # @return [void]
+      def set(plugins)
+        @mutex.synchronize do
+          @plugins.clear
+          plugins.each do |plugin|
+            _add(plugin)
+          end
+        end
+        nil
+      end
+
+      # Enumerates the plugins.
+      # @return [Enumerator]
+      def each(&block)
+        each_plugin do |plugin_wrapper|
+          yield(plugin_wrapper.plugin)
+        end
+      end
+
+      private
+
+      # Not safe to call outside the mutex.
+      def _add(plugin)
+        @plugins << PluginWrapper.new(plugin)
+      end
+
+      # Yield each PluginDetail behind the mutex
+      def each_plugin(&block)
+        @mutex.synchronize do
+          @plugins.each(&block)
+        end
+      end
+
+      # A utility class that computes the canonical name for a plugin
+      # and defers requiring the plugin until the plugin class is
+      # required.
+      # @api private
+      class PluginWrapper
+
+        # @param [String, Symbol, Module, Class] plugin
+        def initialize(plugin)
+          case plugin
+          when Module
+            @canonical_name = plugin.name || plugin.object_id
+            @plugin = plugin
+          when Symbol, String
+            words = plugin.to_s.split('.')
+            @canonical_name = words.pop
+            @gem_name = words.empty? ? nil : words.join('.')
+            @plugin = nil
+          else
+            @canonical_name = plugin.object_id
+            @plugin = plugin
+          end
+        end
+
+        # @return [String]
+        attr_reader :canonical_name
+
+        # @return [Class<Plugin>]
+        def plugin
+          @plugin ||= require_plugin
+        end
+
+        # Returns the given plugin if it is already a PluginWrapper.
+        def self.new(plugin)
+          if plugin.is_a?(self)
+            plugin
+          else
+            super
+          end
+        end
+
+        # @return [Boolean]
+        # @api private
+        def eql? other
+          canonical_name == other.canonical_name
+        end
+
+        # @return [String]
+        # @api private
+        def hash
+          canonical_name.hash
+        end
+
+        private
+
+        # @return [Class<Plugin>]
+        def require_plugin
+          require(@gem_name) if @gem_name
+          plugin_class = Kernel
+          @canonical_name.split('::').each do |const_name|
+            plugin_class = plugin_class.const_get(const_name)
+          end
+          plugin_class
+        end
+
+      end
+    end
+  end
+end

data/lib/seahorse/client/plugins/content_length.rb

@@ -0,0 +1,22 @@
+module Seahorse
+  module Client
+    module Plugins
+      class ContentLength < Plugin
+
+        # @api private
+        class Handler < Client::Handler
+
+          def call(context)
+            length = context.http_request.body.size
+            context.http_request.headers['Content-Length'] = length
+            @handler.call(context)
+          end
+
+        end
+
+        handler(Handler, step: :sign, priority: 0)
+
+      end
+    end
+  end
+end

data/lib/seahorse/client/plugins/endpoint.rb

@@ -0,0 +1,48 @@
+module Seahorse
+  module Client
+    module Plugins
+      # @seahorse.client.option [String] :endpoint
+      #    The HTTP or HTTPS endpoint to send requests to.
+      #    For example:
+      #
+      #        'http://example.com'
+      #        'https://example.com'
+      #        'http://example.com:123'
+      #
+      class Endpoint < Plugin
+
+        option(:endpoint)
+
+        def add_handlers(handlers, config)
+          handlers.add(Handler, priority: 90)
+        end
+
+        def after_initialize(client)
+
+          endpoint = client.config.endpoint
+          if endpoint.nil?
+            msg = "missing required option `:endpoint'"
+            raise ArgumentError, msg
+          end
+
+          endpoint = URI.parse(endpoint.to_s)
+          if URI::HTTPS === endpoint or URI::HTTP === endpoint
+            client.config.endpoint = endpoint
+          else
+            msg = 'expected :endpoint to be a HTTP or HTTPS endpoint'
+            raise ArgumentError, msg
+          end
+        end
+
+        class Handler < Client::Handler
+
+          def call(context)
+            context.http_request.endpoint = URI.parse(context.config.endpoint.to_s)
+            @handler.call(context)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/seahorse/client/plugins/logging.rb

@@ -0,0 +1,37 @@
+module Seahorse
+  module Client
+    module Plugins
+
+      # Enables logging for all requests.  This plugin allows you to configure
+      # your logging device, the log format and the level to log messages at.
+      #
+      # @see Logging::Formatter
+      #
+      # @seahorse.client.option [Logger] :logger (nil) The Logger instance
+      #   to send log messages to.  If this option is not set, logging
+      #   will be disabled.
+      #
+      # @seahorse.client.option [Symbol] :log_level (:info) The log level
+      #   to send messages to the logger at.
+      #
+      # @seahorse.client.option [Logging::LogFormatter] :log_formatter The log
+      #   formatter.  Defaults to {Seahorse::Client::Logging::Formatter.default}.
+      #
+      class Logging < Plugin
+
+        option(:logger, nil)
+
+        option(:log_level, :info)
+
+        option(:log_formatter, Client::Logging::Formatter.default)
+
+        def add_handlers(handlers, config)
+          if config.logger
+            handlers.add(Client::Logging::Handler, step: :validate)
+          end
+        end
+
+      end
+    end
+  end
+end