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

data/lib/aws/response_handler.rb

@@ -9,7 +9,7 @@ module Aws
     attr_accessor :handler
 
     def call(context)
-      @handler.call(context).on_success do |response|
+      @handler.call(context).on(200..299) do |response|
         rules = context.operation.output
         response.error = nil
         response.data = case

data/lib/aws/signers/s3.rb

@@ -131,7 +131,7 @@ module Aws
         # in the canonicalized resource prefixed by a forward slash.
         if bucket = params[:bucket]
           ssl = request.endpoint.https?
-          if Plugins::S3BucketDns.dns_compatible?(bucket.name, ssl)
+          if Plugins::S3BucketDns.dns_compatible?(bucket.value, ssl)
             parts << "/#{bucket.value}"
           end
         end

data/lib/aws/tree_hash.rb

@@ -0,0 +1,69 @@
+require 'openssl'
+
+module Aws
+
+  # Used for computing a tree hash SHA256 checksum of an object.
+  #
+  #    tree_hash = TreeHash.new
+  #    tree_hash.update(file.read(1024 * 1024)) until file.eof?
+  #    tree_hash.digest
+  #
+  # == Limitations and Notes
+  #
+  # There are two main limitations to be aware of when using TreeHash:
+  #
+  # * TreeHash is not thread safe. Use multiple TreeHash objects to concurrently
+  #   compute a tree hash of a large object.  Join their hashes at the end into
+  #   a single TreeHash and then call {#digest}
+  #
+  #      TreeHash.new(tree_hashes.map(&:hashes).flatten)
+  #
+  # * You must call {#update} with 1MB chunks of data.  Only the final
+  #   chunk may be smaller than 1MB.
+  #
+  # If you have a large object/file, and you would like to compute the
+  # chunks concurrently, you must break the original file/data into sections
+  # that are evenly divisible by 1MB.  Each section of data requires
+  # a seperate TreeHash object to compute hashes.  Once all sections of
+  # data are complete, you can rejoin their {#hashes} in sequential order
+  # into a single TreeHash, then call {#digest} on the final tree hash.
+  #
+  class TreeHash
+
+    def initialize(hashes = [])
+      @digest = OpenSSL::Digest::Digest.new('sha256')
+      @hashes = hashes
+    end
+
+    # @return [Array<String>] The built up list of hashes.  Each hash is
+    #   a sha255 digest of a 1MB chunk.
+    attr_accessor :hashes
+
+    # @param [String] chunk
+    # @return [String] Returns the computed SHA256 digest of the chunk.
+    def update(chunk)
+      @hashes << @digest.update(chunk).digest
+      @digest.reset
+      @hashes.last
+    end
+
+    def digest
+      hashes = @hashes
+      digest = OpenSSL::Digest::Digest.new('sha256')
+      until hashes.count == 1
+        hashes = hashes.each_slice(2).map do |h1,h2|
+          digest.reset
+          if h2
+            digest.update(h1)
+            digest.update(h2)
+            digest.digest
+          else
+            h1
+          end
+        end
+      end
+      hashes.first.bytes.map{|x| x.to_i.to_s(16).rjust(2, '0')}.join('')
+    end
+
+  end
+end

data/lib/aws/version.rb

@@ -1,3 +1,3 @@
 module Aws
-  VERSION = '2.0.0.rc2'
+  VERSION = '2.0.0.rc3'
 end

data/spec/aws/json/builder_spec.rb

@@ -44,6 +44,18 @@ module Aws
           expect(json(abc: { mno: 'xyz' })).to eq('{"abc":{"MNO":"xyz"}}')
         end
 
+        it 'does not serialize nil members' do
+          rules['members'] = {
+            'cfg' => {
+              'type' => 'structure',
+              'members' => {
+                'data' => { 'type' => 'blob' },
+              }
+            }
+          }
+          expect(json(cfg: { data: nil })).to eq('{"cfg":{}}')
+        end
+
       end
 
       describe 'lists' do

data/spec/aws/pageable_response_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+module Aws
+  describe PageableResponse do
+
+    let(:resp) { Seahorse::Client::Response.new }
+
+    let(:operation) { double('operation', metadata: { 'paging' => paging }) }
+
+    let(:pager) { PageableResponse.new(resp) }
+
+    let(:paging) { nil }
+
+    before(:each) do
+      resp.context.operation = operation
+    end
+
+    # If an operation has no paging metadata, then it is considered
+    # un-pageable and will always treat a response as the last page.
+    describe 'unpageable-operation' do
+
+      it 'returns true from #last_page?' do
+        expect(pager.last_page?).to be(true)
+        expect(pager.next_page?).to be(false)
+      end
+
+      it 'raises a LastPageError when calling next_page' do
+        expect { pager.next_page }.to raise_error(PageableResponse::LastPageError)
+      end
+
+      it 'popualtes the error with the response' do
+        begin
+          pager.next_page
+        rescue => error
+          expect(error.response).to eq(resp)
+        end
+      end
+
+    end
+
+    # When paging is configured with tokens, the token keys are treated
+    # as request parameters and the values are treated as response data
+    # elements to map into the next request.
+    describe 'paging with tokens' do
+
+      let(:paging) {{
+        'tokens' => {
+          'offset' => 'next_token'
+        }
+      }}
+
+      it 'returns false from last page if the paging token value is present' do
+        resp.data = { 'next_token' => 'OFFSET' }
+        expect(pager.last_page?).to be(false)
+        expect(pager.next_page?).to be(true)
+      end
+
+      it 'is not pageable if response data does not contain tokens' do
+        resp.data = { }
+        expect(pager.last_page?).to be(true)
+        expect(pager.next_page?).to be(false)
+      end
+
+      it 'responds to #next_page by sending a new request with tokens applied' do
+        client = double('client')
+        new_request = double('new-request')
+
+        resp.data = { 'next_token' => 'OFFSET' }
+        resp.context.client = client
+        resp.context.operation_name = 'operation-name'
+
+        expect(client).to receive(:build_request).
+          with('operation-name', { :offset => 'OFFSET' }).
+          and_return(new_request)
+
+        expect(new_request).to receive(:send_request).
+          and_return(Seahorse::Client::Response.new)
+
+        pager.next_page
+      end
+
+    end
+
+    describe 'paging with multiple tokens' do
+
+      let(:paging) {{
+        'tokens' => {
+          'offset_a' => 'group',
+          'offset_b' => 'value',
+        }
+      }}
+
+      it 'returns false from last page if all paging tokens are present' do
+        resp.data = { 'group' => 'a', 'value' => 'b' }
+        expect(pager.last_page?).to be(false)
+        expect(pager.next_page?).to be(true)
+      end
+
+      it 'returns false from last page if ANY paging token is present' do
+        resp.data = { 'group' => 'a' }
+        expect(pager.last_page?).to be(false)
+        expect(pager.next_page?).to be(true)
+      end
+
+      it 'returns true from last page if NO paging tokens are present' do
+        resp.data = { }
+        expect(pager.last_page?).to be(true)
+        expect(pager.next_page?).to be(false)
+      end
+
+      it 'sends any tokens found a request params' do
+        client = double('client')
+        new_request = double('new-request', send_request: nil)
+
+        resp.data = { 'group' => 'a' }
+        resp.context.client = client
+        resp.context.operation_name = 'operation-name'
+
+        expect(client).to receive(:build_request).
+          with('operation-name', { :offset_a => 'a' }).
+          and_return(new_request)
+
+        allow(new_request).to receive(:send_request).and_return(resp)
+
+        pager.next_page
+      end
+
+    end
+
+    describe 'paging with truncation indicator' do
+
+      let(:paging) {{
+        'tokens' => { 'marker' => 'next_marker' },
+        'truncated_if' => 'is_truncated'
+      }}
+
+      it 'returns false from last page if the truncation marker is true' do
+        resp.data = { 'is_truncated' => true }
+        expect(pager.last_page?).to be(false)
+        expect(pager.next_page?).to be(true)
+      end
+
+      it 'returns true from last page if the truncation marker is false' do
+        resp.data = { 'is_truncated' => false }
+        expect(pager.last_page?).to be(true)
+        expect(pager.next_page?).to be(false)
+      end
+
+    end
+
+    describe 'custom paging rules' do
+
+      let(:paging) {{ 'tokens' => { 'offset' => 'next_token' } }}
+
+      it 'can be constructed with an empty set of rules to disable paging' do
+        pager = PageableResponse.new(resp, paging_rules: {})
+        expect(pager.last_page?).to be(true)
+        expect(pager.next_page?).to be(false)
+      end
+
+    end
+
+    describe '#each_page' do
+
+      let(:paging) {{
+        'tokens' => {
+          'offset' => 'next_token'
+        }
+      }}
+
+      it 'yields once per paging result' do
+        client = double('client')
+        new_request = double('new-request')
+
+        resp.data = { 'next_token' => 'OFFSET' }
+        resp.context.client = client
+        resp.context.operation_name = 'operation-name'
+
+        resp2 = Seahorse::Client::Response.new
+        resp2.data = {}
+
+        allow(client).to receive(:build_request).
+          with('operation-name', { :offset => 'OFFSET' }).
+          and_return(new_request)
+
+        allow(new_request).to receive(:send_request).and_return(resp2)
+
+        pages = []
+        pager.each { |r| pages << r }
+        expect(pages).to eq([resp, resp2])
+      end
+
+    end
+  end
+end

data/spec/aws/plugins/retry_errors_spec.rb

@@ -145,6 +145,12 @@ module Aws
             expect(inspector(error, 307).networking?).to be(false)
           end
 
+          it 'returns true if the error is wrapped in a Http::Error' do
+            error = StandardError.new('oops')
+            error = Seahorse::Client::Http::Error.new(error)
+            expect(inspector(error, 200).networking?).to be(true)
+          end
+
         end
       end
 
@@ -247,6 +253,13 @@ module Aws
           expect(resp.context.retries).to eq(3)
         end
 
+        it 'retries Seahorse::Client::Http::Errors' do
+          error = RuntimeError.new('random-runtime-error')
+          resp.error = Seahorse::Client::Http::Error.new(error)
+          handle { |context| resp }
+          expect(resp.context.retries).to eq(3)
+        end
+
       end
     end
   end

data/spec/aws/plugins/signature_v4_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module Aws
+  module Plugins
+    describe SignatureV4 do
+
+      let(:plugin) { SignatureV4.new }
+
+      let(:api) {
+        api = Seahorse::Model::Api.new
+        api.metadata['endpoint_prefix'] = 'svc-name'
+        api
+      }
+
+      let(:config) {
+        cfg = Seahorse::Client::Configuration.new
+        cfg.add_option(:endpoint, 'svc-name.us-west-2.amazonaws.com')
+        cfg.add_option(:api, api)
+        cfg.add_option(:region)
+        cfg
+      }
+
+      describe 'sigv4 signing name' do
+
+        it 'accepts a sigv4 signing name configuration option' do
+          plugin.add_options(config)
+          expect(config.build!(sigv4_name: 'name').sigv4_name).to eq('name')
+        end
+
+        it 'defaults the sigv4 name to the endpoint prefix' do
+          plugin.add_options(config)
+          expect(config.build!.sigv4_name).to eq('svc-name')
+        end
+
+        it 'prefers the signing_name metdata to endpoint_prefix' do
+          api.metadata['signing_name'] = 'signing-name'
+          plugin.add_options(config)
+          expect(config.build!.sigv4_name).to eq('signing-name')
+        end
+
+      end
+
+      describe 'sigv4 signing region' do
+
+        it 'extracts the region from standard endpoints' do
+          plugin.add_options(config)
+          expect(config.build!.sigv4_region).to eq('us-west-2')
+        end
+
+        it 'defaults to us-east-1 for global endpoints' do
+          plugin.add_options(config)
+          cfg = config.build!(endpoint: 'svc-name.amazonaws.com')
+          expect(cfg.sigv4_region).to eq('us-east-1')
+        end
+
+        it 'defaults to configured region if it can not be extract' do
+          plugin.add_options(config)
+          cfg = config.build!(region: 'eu-west-1', endpoint: 'localhost' )
+          expect(cfg.sigv4_region).to eq('eu-west-1')
+        end
+
+      end
+    end
+  end
+end

data/spec/aws/plugins/sqs_queue_urls_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module Aws
+  module Plugins
+    describe SQSQueueUrls do
+
+      let(:config) {
+        cfg = Seahorse::Client::Configuration.new
+        cfg.add_option(:region)
+        cfg.add_option(:sigv4_region)
+        cfg
+      }
+
+      let(:params) {{ queue_url: 'http://foo.com' }}
+
+      def send_request
+        call_handler(SQSQueueUrls::Handler, params:params, config:config)
+      end
+
+      it 'moves the queue url param to the http request endpoint' do
+        resp = send_request
+        expect(resp.http_request.endpoint).to eq('http://foo.com/')
+      end
+
+      it 'resets the configured region based on the queue url' do
+        params[:queue_url] = 'http://sqs.us-west-2.amazonaws.com/url'
+        resp = send_request
+        expect(resp.context.config.region).to eq('us-west-2')
+        expect(resp.context.config.sigv4_region).to eq('us-west-2')
+      end
+
+      it 'raises an argument error for invalid queue urls' do
+        params[:queue_url] = 'oops'
+        expect {
+          send_request
+        }.to raise_error(ArgumentError, "invalid queue url `oops'")
+      end
+
+    end
+  end
+end

data/spec/aws_spec.rb

@@ -15,6 +15,10 @@ module Aws
       expect(Aws.config).to eq({})
     end
 
+    it 'does not allow assigning config object to non-hash objects' do
+      expect(-> { Aws.config = [1,2,3] }).to raise_error(ArgumentError)
+    end
+
   end
 
   describe 'add_plugin' do