aws-sdk-core 2.0.0.rc1 → 2.0.0.rc2

data/tasks/handlers.rake

@@ -0,0 +1,30 @@
+namespace :handlers do
+  Aws.service_classes.each do |svc_name, svc_class|
+
+    # create a task for each service, e.g. handlers:s3
+    desc "Displays handlers for #{svc_class.name}"
+    task(svc_name) do
+      svc = svc_class.new
+      if operation_name = ENV['OPERATION']
+        print_handlers(svc.build_request(operation_name).handlers)
+      else
+        puts ""
+        puts "Diplaying handlers applied to all #{svc_class.name} operations,"
+        puts "  use OPERATION=name to include operation specific handlers"
+        puts ""
+        print_handlers(svc.handlers)
+      end
+    end
+
+  end
+end
+
+def print_handlers(handlers)
+  row = '%-6s %-11s %-9s %s'
+  puts row % ['Order', 'Step', 'Priority', 'Handler Class']
+  puts '---------------------------------------------------------'
+  entries = handlers.entries.sort.reverse.select{ |e| e.operations.empty? }
+  entries.each_with_index do |entry, n|
+    puts row % [n + 1, entry.step, entry.priority, entry.handler_class]
+  end
+end

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

@@ -7,6 +7,7 @@ module Seahorse
     autoload :Handler, 'seahorse/client/handler'
     autoload :HandlerBuilder, 'seahorse/client/handler_builder'
     autoload :HandlerList, 'seahorse/client/handler_list'
+    autoload :ManagedFile, 'seahorse/client/managed_file'
     autoload :ParamConverter, 'seahorse/client/param_converter'
     autoload :ParamValidator, 'seahorse/client/param_validator'
     autoload :Plugin, 'seahorse/client/plugin'

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

@@ -97,24 +97,6 @@ module Seahorse
 
       class << self
 
-        # @option options [String] :endpoint
-        #   Endpoints specify the http scheme, hostname and port to connect
-        #   to.  You must specify at a minimum the hostname.  Endpoints without
-        #   a uri scheme will default to https on port 443.
-        #
-        #       # defaults to https on port 443
-        #       hostname: 'domain.com'
-        #
-        #       # defaults to http on port 80
-        #       hostname: 'domain.com', ssl_default: false
-        #
-        #       # defaults are ignored, as scheme and port are present
-        #       hostname: 'http://domain.com:123'
-        #
-        # @option options [Boolean] :ssl_default (true) Specifies the default
-        #   scheme for the #endpoint when not specified.  Defaults to `true`
-        #   which creates https endpoints.
-        #
         def new(options = {})
           plugins = build_plugins
           options = options.dup

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

@@ -27,13 +27,6 @@ module Seahorse
         @size
       end
 
-      # It is not possible to rewind a {BlockIO} object as the data has
-      # already been yielded.
-      # @return [NotImplementedError]
-      def rewind
-        raise NotImplementedError
-      end
-
     end
   end
 end

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

@@ -51,9 +51,23 @@ module Seahorse
     #
     class Configuration
 
+      # @api private
+      Defaults = Class.new(Array) do
+        def each(&block)
+          reverse.each(&block)
+        end
+      end
+
+      # @api private
+      DynamicDefault = Struct.new(:block) do
+        def call(*args)
+          block.call(*args)
+        end
+      end
+
       # @api private
       def initialize
-        @defaults = {}
+        @defaults = Hash.new { |h,k| h[k] = Defaults.new }
       end
 
       # Adds a getter method that returns the named option or a default
@@ -84,9 +98,8 @@ module Seahorse
       #
       # @return [self]
       def add_option(name, default = nil, &block)
-        @defaults[name.to_sym] = block_given? ?
-          UnresolvedOption.new(Proc.new) :
-          default
+        default = DynamicDefault.new(Proc.new) if block_given?
+        @defaults[name.to_sym] << default
         self
       end
 
@@ -126,7 +139,19 @@ module Seahorse
       # @param [Hash] options ({}) A hash of configuration options.
       # @return [Struct] Returns a frozen configuration `Struct`.
       def build!(options = {})
-        struct = default_struct
+        struct = empty_struct
+        apply_options(struct, options)
+        apply_defaults(struct, options)
+        struct
+      end
+
+      private
+
+      def empty_struct
+        Struct.new(*@defaults.keys.sort).new
+      end
+
+      def apply_options(struct, options)
         options.each do |opt, value|
           begin
             struct[opt] = value
@@ -135,62 +160,57 @@ module Seahorse
             raise ArgumentError, msg
           end
         end
-        OptionBlockResolver.new(struct).struct.freeze
       end
 
-      private
-
-      def default_struct
-        Struct.new(*@defaults.keys).new(*@defaults.values_at(*@defaults.keys))
-      end
-
-      # @api private
-      class UnresolvedOption
-
-        def initialize(block)
-          @block = block
+      def apply_defaults(struct, options)
+        @defaults.each do |opt_name, defaults|
+          unless options.key?(opt_name)
+            struct[opt_name] = defaults
+          end
         end
-
-        attr_reader :block
-
+        DefaultResolver.new(struct).resolve
       end
 
       # @api private
-      class OptionBlockResolver
+      class DefaultResolver
 
         def initialize(struct)
           @struct = struct
           @members = Set.new(@struct.members)
-          @struct.members.each do |opt|
-            if struct[opt].is_a?(UnresolvedOption)
-              struct[opt] = struct[opt].block.call(self)
-            end
-          end
         end
 
-        attr_reader :struct
+        def resolve
+          @members.each { |opt_name| value_at(opt_name) }
+        end
 
-        def respond_to?(method_name)
-          @members.include?(method_name.to_sym) || super
+        def respond_to?(method_name, *args)
+          @members.include?(method_name) or super
         end
 
         private
 
+        def value_at(opt_name)
+          value = @struct[opt_name]
+          value.is_a?(Defaults) ? resolve_defaults(opt_name, value) : value
+        end
+
+        def resolve_defaults(opt_name, defaults)
+          defaults.each do |default|
+            default = default.call(self) if default.is_a?(DynamicDefault)
+            @struct[opt_name] = default
+            break if !default.nil?
+          end
+          @struct[opt_name]
+        end
+
         def method_missing(method_name, *args)
           if @members.include?(method_name)
-            resolve_blocks(method_name)
+            value_at(method_name)
           else
             super
           end
         end
 
-        def resolve_blocks(member)
-          if @struct[member].is_a?(UnresolvedOption)
-            @struct[member] = @struct[member].block.call(self)
-          end
-          @struct[member]
-        end
-
       end
     end
   end

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

@@ -20,33 +20,109 @@ module Seahorse
         end
       end
 
-      # @api private
-      Entry = Struct.new(:klass, :options, :operations, :priority, :inserted) do
+      class Entry
+
+        # @api private
+        STEPS = {
+          initialize: 400,
+          validate: 300,
+          build: 200,
+          sign: 100,
+          send: 0,
+        }
+
+        def initialize(handler, inserted, options)
+          @handler = handler
+          @inserted = inserted
+          @operations = Set.new((options[:operations] || []).map(&:to_s))
+          @step = :build
+          @priority = 50
+          self.step = options[:step] if options[:step]
+          self.priority = options[:priority] if options[:priority]
+          compute_weight unless @weight
+        end
+
+        # @return [Handler, Class<Handler>] Returns the handler.  This may
+        #   be a constructed handler object or a handler class.
+        attr_accessor :handler
+
+        # @return [Integer] The insertion order/position.  This is used to
+        #   determine sort order when two entries have the same priority.
+        #   Entries inserted later (with a higher inserted value) have a
+        #   lower priority.
+        attr_accessor :inserted
+
+        # @return [Symbol]
+        attr_accessor :step
+
+        # @return [Integer]
+        attr_accessor :priority
+
+        # @return [Set<String>]
+        attr_accessor :operations
+
+        # @return [Integer]
+        attr_accessor :weight
+
+        # @return [Class]
+        def handler_class
+          handler.is_a?(Class) ? handler : handler.class
+        end
+
+        # @param [Symbol] step
+        def step=(step)
+          raise InvalidStepError, step unless STEPS.key?(step)
+          @step = step
+          compute_weight
+        end
+
+        # @param [Integer<0..99>] priority
+        def priority=(priority)
+          raise InvalidPriorityError, priority unless (0..99).include?(priority)
+          @priority = priority
+          compute_weight
+        end
+
+        # @api private
+        def dup
+          duplicate = super
+          duplicate.operations = operations.dup
+          duplicate
+        end
+
+        # @api private
         def <=>(other)
-          if priority == other.priority
-            inserted <=> other.inserted
+          if weight == other.weight
+            other.inserted <=> inserted
           else
-            priority <=> other.priority
+            weight <=> other.weight
           end
         end
-      end
 
-      # @api private
-      STEPS = {
-        initialize: 300,
-        validate: 200,
-        build: 100,
-        sign: 0,
-      }
+        private
+
+        def compute_weight
+          @weight = STEPS[@step] + @priority
+        end
+
+      end
 
       include Enumerable
 
       # @api private
       def initialize(options = {})
         @index = options[:index] || 0
-        @send = options[:send]
-        @handlers = options[:handlers] || []
+        @entries = {}
         @mutex = Mutex.new
+        entries = options[:entries] || []
+        add_entries(entries) unless entries.empty?
+      end
+
+      # @return [Array<Entry>]
+      def entries
+        @mutex.synchronize do
+          @entries.values
+        end
       end
 
       # Registers a handler.  Handlers are used to build a handler stack.
@@ -126,36 +202,23 @@ module Seahorse
       #
       # @return [Class<Handler>] Returns the handler class that was added.
       #
-      def add(handler_class, options = {})
+      def add(handler, 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
+          add_entry(Entry.new(handler, next_index, options))
         end
-        handler_class
+        handler
       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
+        entries = source_list.entries.collect do |entry|
+          new_entry = entry.dup
+          new_entry.inserted = next_index
+          new_entry
         end
+        add_entries(entries)
       end
 
       # Returns a handler list for the given operation.  The returned
@@ -164,22 +227,13 @@ module Seahorse
       # @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
+        HandlerList.new(index: @index, entries: filter(operation.to_s))
       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
+        entries.sort.each do |entry|
+          yield(entry.handler) if entry.operations.empty?
         end
       end
 
@@ -200,51 +254,34 @@ module Seahorse
 
       private
 
-      def operations(options)
-        options[:operations] ? Set.new(options[:operations].map(&:to_s)) : nil
+      def add_entries(entries)
+        @mutex.synchronize do
+          entries.each { |entry| add_entry(entry) }
+        end
+      end
+
+      def add_entry(entry)
+        key = entry.step == :send ? :send : entry.object_id
+        @entries[key] = entry
       end
 
       def filter(operation)
-        filtered = []
-        @handlers.each do |handler|
-          if handler.operations.nil?
+        entries.inject([]) do |filtered, handler|
+          if handler.operations.empty?
             filtered << handler
           elsif handler.operations.include?(operation)
             handler = handler.dup
-            handler.operations = nil
+            handler.operations.clear
             filtered << handler
           end
+          filtered
         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