aws-sdk-core 2.0.0.rc1

data/vendor/seahorse/lib/seahorse/client/handler.rb

@@ -0,0 +1,26 @@
+module Seahorse
+  module Client
+    class Handler
+
+      # @param [Handler] handler (nil) The next handler in the stack that
+      #   should be called from within the {#call} method.  This value
+      #   must only be nil for send handlers.
+      def initialize(handler = nil)
+        @handler = handler
+      end
+
+      # @return [Handler, nil]
+      attr_accessor :handler
+
+      # @param [RequestContext] context
+      # @return [Response]
+      def call(context)
+        @handler.call(context)
+      end
+
+      def inspect
+        "#<#{self.class.name||'UnnamedHandler'} @handler=#{@handler.inspect}>"
+      end
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/handler_builder.rb

@@ -0,0 +1,49 @@
+module Seahorse
+  module Client
+
+    # This module provides the ability to add handlers to a class or
+    # module.  The including class or extending module must respond to
+    # `#handlers`, returning a {HandlerList}.
+    module HandlerBuilder
+
+      def handle_request(*args, &block)
+        handler(*args) do |context|
+          block.call(context)
+          @handler.call(context)
+        end
+      end
+
+      def handle_response(*args, &block)
+        handler(*args) do |context|
+          @handler.call(context).on_complete do |response|
+            block.call(response)
+          end
+        end
+      end
+
+      def handle(*args, &block)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        handler_class = block ? handler_for(*args, &block) : args.first
+        handlers.add(handler_class, options)
+      end
+      alias handler handle
+
+      # @api private
+      def handler_for(name = nil, &block)
+        if name
+          const_set(name, new_handler(block))
+        else
+          new_handler(block)
+        end
+      end
+
+      # @api private
+      def new_handler(block)
+        Class.new(Handler) do
+          define_method(:call, &block)
+        end
+      end
+
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/handler_list.rb

@@ -0,0 +1,250 @@
+require 'thread'
+require 'set'
+
+module Seahorse
+  module Client
+    class HandlerList
+
+      class InvalidStepError < ArgumentError
+        def initialize(step)
+          msg = "invalid :step `%s', must be one of :validate, :build, "
+          msg << ":sign or :send"
+          super(msg % step.inspect)
+        end
+      end
+
+      class InvalidPriorityError < ArgumentError
+        def initialize(priority)
+          msg = "invalid :priority `%s', must be between 0 and 99"
+          super(msg % priority.inspect)
+        end
+      end
+
+      # @api private
+      Entry = Struct.new(:klass, :options, :operations, :priority, :inserted) do
+        def <=>(other)
+          if priority == other.priority
+            inserted <=> other.inserted
+          else
+            priority <=> other.priority
+          end
+        end
+      end
+
+      # @api private
+      STEPS = {
+        initialize: 300,
+        validate: 200,
+        build: 100,
+        sign: 0,
+      }
+
+      include Enumerable
+
+      # @api private
+      def initialize(options = {})
+        @index = options[:index] || 0
+        @send = options[:send]
+        @handlers = options[:handlers] || []
+        @mutex = Mutex.new
+      end
+
+      # Registers a handler.  Handlers are used to build a handler stack.
+      # Handlers default to the `:build` step with default priority of 50.
+      # The step and priority determine where in the stack a handler
+      # will be.
+      #
+      # ## Handler Stack Ordering
+      #
+      # A handler stack is built from the inside-out.  The stack is
+      # seeded with the send handler.  Handlers are constructed recursively
+      # in reverse step and priority order so that the highest priority
+      # handler is on the outside.
+      #
+      # By constructing the stack from the inside-out, this ensures
+      # that the validate handlers will be called first and the sign handlers
+      # will be called just before the final and only send handler is called.
+      #
+      # ## Steps
+      #
+      # Handlers are ordered first by step.  These steps represent the
+      # life-cycle of a request.  Valid steps are:
+      #
+      # * `:initialize`
+      # * `:validate`
+      # * `:build`
+      # * `:sign`
+      # * `:send`
+      #
+      # Many handlers can be added to the same step, except for `:send`.
+      # There can be only one `:send` handler.  Adding an additional
+      # `:send` handler replaces the previous one.
+      #
+      # ## Priorities
+      #
+      # Handlers within a single step are executed in priority order.  The
+      # higher the priority, the earlier in the stack the handler will
+      # be called.
+      #
+      # * Handler priority is an integer between 0 and 99, inclusively.
+      # * Handler priority defaults to 50.
+      # * When multiple handlers are added to the same step with the same
+      #   priority, the last one added will have the highest priority and
+      #   the first one added will have the lowest priority.
+      #
+      # @param [Class<Handler>] handler_class This should be a subclass
+      #   of {Handler} or any class that construct an object that
+      #   responds to `#call`.
+      #
+      # @option options [Symbol] :step (:build) The request life-cycle
+      #   step the handler should run in.  Defaults to `:build`.  The
+      #   list of possible steps, in high-to-low priority order are:
+      #
+      #   * `:validate`
+      #   * `:build`
+      #   * `:sign`
+      #   * `:send`
+      #
+      #   There can only be one send handler. Registering an additional
+      #   `:send` handler replaces the previous one.
+      #
+      # @option options [Integer] :priority (50) The priority of this
+      #   handler within a step.  The priority must be between 0 and 99
+      #   inclusively.  It defaults to 50.  When two handlers have the
+      #   same `:step` and `:priority`, the handler registered last has
+      #   the highest priority.
+      #
+      # @option options [Array<Symbol,String>] :operations A list of
+      #   operations names the handler should be applied to.  When
+      #   `:operations` is omitted, the handler is applied to all
+      #   operations for the client.
+      #
+      # @raise [InvalidStepError]
+      # @raise [InvalidPriorityError]
+      # @note There can be only one `:send` handler.  Adding an additional
+      #   send handler replaces the previous.
+      #
+      # @return [Class<Handler>] Returns the handler class that was added.
+      #
+      def add(handler_class, options = {})
+        @mutex.synchronize do
+          if options[:step] == :send
+            @send = handler_class
+          else
+            @handlers << Entry.new(
+              handler_class,
+              options,
+              operations(options),
+              priority(options),
+              next_index,
+            )
+          end
+        end
+        handler_class
+      end
+
+      # Copies handlers from the `source_list` onto the current handler list.
+      # @param [HandlerList] source_list
+      # @return [void]
+      def copy_from(source_list)
+        @mutex.synchronize do
+          send, handlers = source_list.send(:handlers)
+          @send = send if send
+          handlers.each do |handler|
+            new_handler = handler.dup
+            new_handler.inserted = next_index
+            @handlers << new_handler
+          end
+        end
+      end
+
+      # Returns a handler list for the given operation.  The returned
+      # will have the operation specific handlers merged with the common
+      # handlers.
+      # @param [String] operation The name of an operation.
+      # @return [HandlerList]
+      def for(operation)
+        @mutex.synchronize do
+          HandlerList.new(
+            index: @index,
+            send: @send,
+            handlers: filter(operation.to_s),
+          )
+        end
+      end
+
+      # Yields the handlers in stack order, which is reverse priority.
+      def each(&block)
+        @mutex.synchronize do
+          yield(@send) if @send
+          @handlers.sort.each do |handler|
+            yield(handler.klass) if handler.operations.nil?
+          end
+        end
+      end
+
+      # Constructs the handlers recursively, building a handler stack.
+      # The `:send` handler will be at the top of the stack and the
+      # `:validate` handlers will be at the bottom.
+      # @return [Handler]
+      def to_stack
+        inject(nil) do |stack, handler|
+          if handler.is_a?(Class)
+            handler = handler.new(stack)
+          else
+            handler.handler = stack
+            handler
+          end
+        end
+      end
+
+      private
+
+      def operations(options)
+        options[:operations] ? Set.new(options[:operations].map(&:to_s)) : nil
+      end
+
+      def filter(operation)
+        filtered = []
+        @handlers.each do |handler|
+          if handler.operations.nil?
+            filtered << handler
+          elsif handler.operations.include?(operation)
+            handler = handler.dup
+            handler.operations = nil
+            filtered << handler
+          end
+        end
+        filtered
+      end
+
+      def next_index
+        @index += 1
+      end
+
+      # @return [Integer]
+      def priority(options)
+        step_value(options) + priority_value(options)
+      end
+
+      # @return [Integer]
+      def step_value(options)
+        step = options[:step] || :build
+        raise InvalidStepError, step unless STEPS.key?(step)
+        STEPS[step]
+      end
+
+      # @return [Integer]
+      def priority_value(options)
+        priority = options[:priority] || 50
+        raise InvalidPriorityError, priority unless (0..99).include?(priority)
+        priority
+      end
+
+      def handlers
+        [@send, @handlers]
+      end
+
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/http/endpoint.rb

@@ -0,0 +1,95 @@
+require 'uri'
+
+module Seahorse
+  module Client
+    module Http
+
+      # # Constructing an Endpoint
+      #
+      # You can construct an endpoint from a string like so:
+      #
+      #     puts Endpoint.new('http://foo.com:123')
+      #     #=> 'http://foo.com'
+      #
+      # If you omit the protocol, it will default to a HTTPS endpoint:
+      #
+      #     puts Endpoint.new('foo.com')
+      #     #=> 'https://foo.com'
+      #
+      # You can default to a HTTP endpoint by passing `:ssl_default` as `false`:
+      #
+      #     puts Endpoint.new('foo.com', ssl_default: false)
+      #     #=> 'http://foo.com'
+      #
+      class Endpoint
+
+        # @param [Endpoint, String] endpoint
+        # @option options [Boolean] :ssl_default (true)
+        def initialize(endpoint, options = {})
+          endpoint = endpoint.to_s
+          unless endpoint =~ /^http/
+            endpoint = apply_scheme(endpoint, options)
+          end
+          URI.parse(endpoint).tap do |uri|
+            @scheme = uri.scheme
+            @host = uri.host
+            @port = uri.port
+            @user = uri.user
+            @password = uri.password
+          end
+        end
+
+        # @return [String] Returns the endpoint scheme ('https' or 'http').
+        attr_accessor :scheme
+
+        # @return [String] Returns the endpoint host (e.g. 'foo.com')
+        attr_accessor :host
+
+        # @return [Integer] Returns the endpoint port number (e.g. 443).
+        attr_accessor :port
+
+        # @return [String, nil]
+        attr_accessor :user
+
+        # @return [String, nil]
+        attr_accessor :password
+
+        # @return [Boolean]
+        def http?
+          @scheme == 'http'
+        end
+
+        # @return [Boolean]
+        def https?
+          @scheme == 'https'
+        end
+
+        # @return [String]
+        # @api private
+        def inspect
+          URI.parse("#{@scheme}://#{userpass}#{@host}:#{@port}").to_s
+        end
+        alias to_str inspect
+        alias to_s inspect
+
+        # @return [Boolean]
+        # @api private
+        def eq(other)
+          to_s == other.to_s
+        end
+        alias == eq
+
+        private
+
+        def apply_scheme(endpoint, options)
+          "http#{options.fetch(:ssl_default, true) ? 's' : ''}://#{endpoint}"
+        end
+
+        def userpass
+          [@user, @password].compact.join(':') + '@' if @user
+        end
+
+      end
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/http/headers.rb

@@ -0,0 +1,94 @@
+module Seahorse
+  module Client
+    module Http
+      class Headers
+
+        include Enumerable
+
+        # @api private
+        def initialize(headers = {})
+          @data = {}
+          headers.each_pair do |key, value|
+            self[key] = value
+          end
+        end
+
+        # @param [String] key
+        # @return [String]
+        def [](key)
+          @data[key.to_s.downcase]
+        end
+
+        # @param [String] key
+        # @param [String] value
+        def []=(key, value)
+          @data[key.to_s.downcase] = value.to_s
+        end
+
+        # @param [Hash] headers
+        # @return [Headers]
+        def update(headers)
+          headers.each_pair do |k, v|
+            self[k] = v
+          end
+          self
+        end
+
+        # @param [String] key
+        def delete(key)
+          @data.delete(key.to_s.downcase)
+        end
+
+        # @return [Array<String>]
+        def keys
+          @data.keys
+        end
+
+        # @return [Array<String>]
+        def values
+          @data.values
+        end
+
+        # @return [Array<String>]
+        def values_at(*keys)
+          @data.values_at(*keys.map{ |key| key.to_s.downcase })
+        end
+
+        # @yield [key, value]
+        # @yieldparam [String] key
+        # @yieldparam [String] value
+        # @return [nil]
+        def each(&block)
+          if block_given?
+            @data.each_pair do |key, value|
+              yield(key, value)
+            end
+            nil
+          else
+            @data.enum_for(:each)
+          end
+        end
+        alias each_pair each
+
+        # @return [Boolean] Returns `true` if the header is set.
+        def key?(key)
+          @data.key?(key.to_s.downcase)
+        end
+        alias has_key? key?
+        alias include? key?
+
+        # @return [Hash]
+        def to_hash
+          @data.dup
+        end
+        alias to_h to_hash
+
+        # @api private
+        def inspect
+          @data.inspect
+        end
+
+      end
+    end
+  end
+end