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

data/spec/fixtures/operations/glacier/get_job_output.yml

@@ -0,0 +1,23 @@
+# This test ensures the GetJobOutput operation correctly manages the
+# http status code response.
+operation: get_job_output
+params:
+  :vault_name: 'vault'
+  :job_id: 'id'
+response:
+  status_code: 200
+  headers:
+    "x-amz-sha256-tree-hash": 'checksum'
+    "Content-Range": 'range'
+    "Accept-Ranges": 'accept-ranges'
+    "Content-Type": 'content-type'
+    "x-amz-archive-description": 'desc'
+  body: '{ "job": "output" }'
+data:
+  :body: '{ "job": "output" }'
+  :checksum: 'checksum'
+  :content_range: 'range'
+  :accept_ranges: 'accept-ranges'
+  :content_type: 'content-type'
+  :status: 200
+  :archive_description: 'desc'

data/spec/fixtures/operations/s3/get_bucket_policy.yml

@@ -0,0 +1,8 @@
+operation: get_bucket_policy
+params:
+  :bucket: 'bucket-name'
+response:
+  status_code: 200
+  body: '{ "policy": "json-document" }'
+data:
+  :policy: '{ "policy": "json-document" }'

data/tasks/endpoints.rake

@@ -0,0 +1,15 @@
+namespace :endpoints do
+
+  desc 'Downloads a fresh copy of the endpoints.json'
+  task :download do
+    require 'net/http'
+    require 'uri'
+    host = 'aws-sdk-configurations.amazonwebservices.com'
+    uri = URI.parse("http://#{host}/endpoints.json")
+    response = Net::HTTP.get_response(uri)
+    root = File.dirname(File.dirname(__FILE__))
+    target = File.join(root, 'apis', 'configuration', 'endpoints.json')
+    File.open(target, 'w') { |file| file.write(response.body) }
+  end
+
+end

data/tasks/handlers.rake

@@ -2,7 +2,7 @@ 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}"
+    desc "Displays handlers for #{svc_class.name}" if ENV['ALL']
     task(svc_name) do
       svc = svc_class.new
       if operation_name = ENV['OPERATION']

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

@@ -18,6 +18,7 @@ module Seahorse
 
     module Http
       autoload :Endpoint, 'seahorse/client/http/endpoint'
+      autoload :Error, 'seahorse/client/http/error'
       autoload :Headers, 'seahorse/client/http/headers'
       autoload :PlainStringIO, 'seahorse/client/http/plain_string_io'
       autoload :Request, 'seahorse/client/http/request'

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

@@ -1,3 +1,5 @@
+require 'thread'
+
 module Seahorse
   module Client
     class Base
@@ -106,6 +108,9 @@ module Seahorse
           client
         end
 
+        # Used by plugins that modify the client class.
+        attr_reader :mutex
+
         # Registers a plugin with this client.
         #
         # @example Register a plugin
@@ -213,6 +218,7 @@ module Seahorse
 
         def inherited(subclass)
           subclass.instance_variable_set('@plugins', PluginList.new(@plugins))
+          subclass.instance_variable_set("@mutex", Mutex.new)
         end
 
       end

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

@@ -54,7 +54,7 @@ module Seahorse
       # @api private
       Defaults = Class.new(Array) do
         def each(&block)
-          reverse.each(&block)
+          reverse.to_a.each(&block)
         end
       end
 

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

@@ -15,9 +15,9 @@ module Seahorse
 
       def handle_response(*args, &block)
         handler(*args) do |context|
-          @handler.call(context).on_complete do |response|
-            block.call(response)
-          end
+          resp = @handler.call(context)
+          block.call(resp) if resp.http_response.status_code > 0
+          resp
         end
       end
 

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

@@ -168,8 +168,8 @@ module Seahorse
       #   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
+      # @param [Class<Handler>] handler This should be a subclass
+      #   of {Handler} or anany class that construct an object that
       #   responds to `#call`.
       #
       # @option options [Symbol] :step (:build) The request life-cycle

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

@@ -0,0 +1,17 @@
+module Seahorse
+  module Client
+    module Http
+      class Error < StandardError
+
+        def initialize(error)
+          super(error.message)
+          set_backtrace(error.backtrace)
+          @original_error = error
+        end
+
+        attr_reader :original_error
+
+      end
+    end
+  end
+end

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

@@ -5,6 +5,16 @@ module Seahorse
     module Http
       class PlainStringIO < StringIO
         def inspect; string.inspect end
+
+        def eq?(other)
+          if other.is_a?(String) and self.string == other
+            true
+          else
+            super
+          end
+        end
+        alias == eq?
+
       end
     end
   end

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

@@ -7,7 +7,7 @@ module Seahorse
         # @return [Response]
         def call(context)
           context[:logging_started_at] = Time.now
-          @handler.call(context).on_complete do |response|
+          @handler.call(context).tap do |response|
             context[:logging_completed_at] = Time.now
             log(context.config, response)
           end

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

@@ -6,6 +6,12 @@ module Seahorse
       # the Ruby's `Net::HTTP`.
       class Handler < Client::Handler
 
+        NETWORK_ERRORS = [
+          SocketError, EOFError, IOError, Timeout::Error,
+          Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE,
+          Errno::EINVAL, Errno::ETIMEDOUT, OpenSSL::SSL::SSLError
+        ]
+
         # Raised when a {Handler} can not construct a `Net::HTTP::Request`
         # from the given http verb.
         class InvalidHttpVerbError < StandardError; end
@@ -13,8 +19,13 @@ module Seahorse
         # @param [RequestContext] context
         # @return [Response]
         def call(context)
-          transmit(context.config, context.http_request, context.http_response)
-          Response.new(context: context)
+          response = Response.new(context: context)
+          begin
+            transmit(context.config, context.http_request, context.http_response)
+          rescue *NETWORK_ERRORS => error
+            response.error = Http::Error.new(error)
+          end
+          response
         end
 
         # @param [Configuration] config

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

@@ -19,7 +19,7 @@ module Seahorse
 
           def call(context)
             context.http_request.body = MultiJson.dump(context.params)
-            @handler.call(context).on_success do |resp|
+            @handler.call(context).on(200..299) do |resp|
               resp.data = MultiJson.load(resp.http_response.body_contents)
             end
           end

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

@@ -7,7 +7,7 @@ module Seahorse
       #
       # # Helper Methods
       #
-      # This plugin adds a helper method that lists the availalbe API
+      # This plugin adds a helper method that lists the available API
       # operations.
       #
       #     client.operation_names
@@ -27,7 +27,9 @@ module Seahorse
 
         def after_initialize(client)
           unless client.respond_to?(:operation_names)
-            add_operation_helpers(client, client.config.api.operations.keys)
+            client.class.mutex.synchronize do
+              add_operation_helpers(client, client.config.api.operations.keys)
+            end
           end
         end
 

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

@@ -10,7 +10,7 @@ module Seahorse
 
           def call(context)
             build_request(context)
-            @handler.call(context).on_success do |response|
+            @handler.call(context).on(200..299) do |response|
               parse_response(response)
             end
           end
@@ -71,10 +71,18 @@ module Seahorse
           def parse_response(response)
             output = response.context.operation.output
             response.data ||= Aws::Structure.new(output.members.keys)
+            extract_status_code(response)
             extract_headers(response)
             extract_body(response)
           end
 
+          def extract_status_code(response)
+            if member = response.context.operation.output.status_code_member
+              status_code = response.http_response.status_code
+              response.data[member.member_name] = status_code
+            end
+          end
+
           def extract_headers(response)
             headers = response.http_response.headers
             rules = response.context.operation.output.header_members

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

@@ -33,10 +33,18 @@ module Seahorse
       # You can stream the raw HTTP response body to a File, or any IO-like
       # object, by passing the `:target` option.
       #
+      #     # create a new file at the given path
+      #     request.send_request(target: '/path/to/target/file')
+      #
+      #     # or provide an IO object to write to
       #     File.open('photo.jpg', 'wb') do |file|
       #       request.send_request(target: file)
       #     end
       #
+      # **Please Note**: The target IO object may receive `#truncate(0)`
+      # if the request generates a networking error and bytes have already
+      # been written to the target.
+      #
       # ## Block Streaming
       #
       # Pass a block to `#send_request` and the response will be yielded in
@@ -50,7 +58,13 @@ module Seahorse
       # **Please Note**: When streaming to a block, it is not possible to
       # retry failed requests.
       #
+      # @option options [String, IO] :target When specified, the HTTP response
+      #   body is written to target.  This is helpful when you are sending
+      #   a request that may return a large payload that you don't want to
+      #   load into memory.
+      #
       # @return [Response]
+      #
       def send_request(options = {}, &block)
         set_target(options, &block)
         resp = @handlers.to_stack.call(@context)

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

@@ -32,47 +32,17 @@ module Seahorse
       # @return [StandardError, nil]
       attr_accessor :error
 
-      # @param [Range<Integer>] status_code_range (nil) When present, the
-      #   `block` will be triggered only for responses with a status code
-      #   in the given range.
-      # @return [Response] Returns self.
-      def on_status(status_code_range = nil, &block)
-        if status_code_range.nil? || status_code_range.include?(status_code)
-          yield(self)
-        end
+      # @param [Integer,Range<Integer>] status_code_range The block will be
+      #   triggered only for responses with a status code that matches
+      #   the given status code or status code range.
+      # @return [self]
+      def on(status_code_range, &block)
+        range = status_code_range
+        range = range..range if range.is_a?(Integer)
+        yield(self) if range.include?(status_code)
         self
       end
 
-      # Yields to the given block if the HTTP request received a response.
-      def on_complete(&block)
-        on_status(200..599, &block)
-      end
-
-      # Yields to the given block if the HTTP request received response with a
-      # ~ 200 level status code.
-      def on_success(&block)
-        on_status(200..299, &block)
-      end
-
-      # Yields to the given block if the HTTP request received response with a
-      # ~ 300 level status code.
-      def on_redirect(&block)
-        on_status(300..399, &block)
-      end
-
-      # Yields to the given block if the HTTP request received response with a
-      # ~ 400 or 500 level status code.
-      def on_error(&block)
-        on_status(400..599, &block)
-      end
-
-      # Yields to the given block if the HTTP request failed to receive any
-      # response.  This generally indicates there was a network 
-      # level status code.
-      def on_failure(&block)
-        on_status(0..0, &block)
-      end
-
       # @api private
       def respond_to?(*args)
         @data.respond_to?(args.first, false) || super

data/vendor/seahorse/lib/seahorse/model/shapes/shape.rb

@@ -1,4 +1,3 @@
-
 module Seahorse
   module Model
     module Shapes
@@ -170,6 +169,10 @@ module Seahorse
           member_map['body']
         end
 
+        def status_code_member
+          member_map['http_status'].values.first
+        end
+
         # @return [StructureShape] Returns a structure with each of the
         #   members that represent the request body.
         def payload_member
@@ -189,14 +192,19 @@ module Seahorse
         # @return [Boolean] Returns `true` if the request input body
         #   should be sent as blob/raw data (e.g. from a file).
         def raw_payload?
-          payload_member.is_a?(BlobShape)
+          !payload_member.is_a?(StructureShape)
         end
 
         private
 
         def member_map
           @member_map ||= begin
-            { 'header' => {}, 'uri' => {}, 'body' => {} }.tap do |map|
+            {
+              'http_status' => {},
+              'header' => {},
+              'uri' => {},
+              'body' => {} 
+            }.tap do |map|
               members.each do |member_name, member|
                 map[member.location][member_name] = member
               end

data/vendor/seahorse/spec/seahorse/client/configuration_spec.rb

@@ -103,6 +103,19 @@ module Seahorse
           expect(config.build!.proc).to be(value)
         end
 
+        it 'resolves defaults in LIFO order until a non-nil value is found' do
+          # default cost is 10
+          config.add_option(:cost) { 10 }
+
+          # increase cost for red items
+          config.add_option(:cost) { |cfg| cfg.color == 'red' ? 9001 : nil }
+
+          config.add_option(:color)
+
+          expect(config.build!(color: 'green').cost).to eq(10)
+          expect(config.build!(color: 'red').cost).to eq(9001) # over 9000!
+        end
+
       end
     end
   end

data/vendor/seahorse/spec/seahorse/client/net_http/handler_spec.rb

@@ -225,6 +225,12 @@ module Seahorse
               expect(resp_body.read).to eq('response-body')
             end
 
+            it 'wraps errors with a Http::Error' do
+              stub_request(:any, endpoint).to_raise(EOFError)
+              resp = make_request
+              expect(resp.error).to be_a(Seahorse::Client::Http::Error)
+            end
+
           end
         end
       end

data/vendor/seahorse/spec/seahorse/client/response_spec.rb

@@ -87,80 +87,26 @@ module Seahorse
           Response.new(context: RequestContext.new(http_response: http_resp))
         }
 
-        describe '#on_complete' do
+        describe '#on' do
 
-          it 'triggers the callback when a response is received' do
+          it 'triggers the callback when status code matches' do
             http_resp.status_code = 200
-            expect { |b| response.on_complete(&b) }.to yield_control
+            expect { |b| response.on(200,&b) }.to yield_control
           end
 
-          it 'does not trigger when when a response is not received' do
-            http_resp.status_code = 0
-            expect { |b| response.on_complete(&b) }.not_to yield_control
-          end
-
-        end
-
-        describe '#on_success' do
-
-          it 'triggers the callback when response has a ~ 200 status code' do
-            http_resp.status_code = 0
-            expect { |b| response.on_success(&b) }.not_to yield_control
-            http_resp.status_code = 200
-            expect { |b| response.on_success(&b) }.to yield_control
-            http_resp.status_code = 299
-            expect { |b| response.on_success(&b) }.to yield_control
-            http_resp.status_code = 300
-            expect { |b| response.on_success(&b) }.not_to yield_control
-          end
-
-        end
-
-        describe '#on_redirect' do
-
-          it 'triggers the callback when response has a ~ 300 status code' do
-            http_resp.status_code = 200
-            expect { |b| response.on_redirect(&b) }.not_to yield_control
-            http_resp.status_code = 304
-            expect { |b| response.on_redirect(&b) }.to yield_control
+          it 'triggers the callback when status code included' do
             http_resp.status_code = 307
-            expect { |b| response.on_redirect(&b) }.to yield_control
-            http_resp.status_code = 400
-            expect { |b| response.on_redirect(&b) }.not_to yield_control
+            expect { |b| response.on(300..599,&b) }.to yield_control
           end
 
-        end
-
-        describe '#on_error' do
-
-          it 'triggers the callback when response has a ~ 400-500 code' do
-            http_resp.status_code = 0
-            expect { |b| response.on_error(&b) }.not_to yield_control
-            http_resp.status_code = 200
-            expect { |b| response.on_error(&b) }.not_to yield_control
+          it 'does not trigger when when a response is not included' do
             http_resp.status_code = 300
-            expect { |b| response.on_error(&b) }.not_to yield_control
-            http_resp.status_code = 400
-            expect { |b| response.on_error(&b) }.to yield_control
-            http_resp.status_code = 500
-            expect { |b| response.on_error(&b) }.to yield_control
+            expect { |b| response.on(200..299,&b) }.not_to yield_control
           end
 
-        end
-
-        describe '#on_failure' do
-
-          it 'triggers the callback when a response is not received' do
-            http_resp.status_code = 0
-            expect { |b| response.on_failure(&b) }.to yield_control
-            http_resp.status_code = 200
-            expect { |b| response.on_failure(&b) }.not_to yield_control
+          it 'returns self' do
             http_resp.status_code = 300
-            expect { |b| response.on_failure(&b) }.not_to yield_control
-            http_resp.status_code = 400
-            expect { |b| response.on_failure(&b) }.not_to yield_control
-            http_resp.status_code = 500
-            expect { |b| response.on_failure(&b) }.not_to yield_control
+            expect(response.on(300) { |r| }).to be(response)
           end
 
         end