aws-sdk-s3 1.0.0.rc1

data/lib/aws-sdk-s3/plugins/bucket_dns.rb

@@ -0,0 +1,89 @@
+module Aws
+  module S3
+    module Plugins
+
+      # Amazon S3 requires DNS style addressing for buckets outside of
+      # the classic region when possible.
+      class BucketDns < Seahorse::Client::Plugin
+
+        # When set to `false` DNS compatible bucket names are moved from
+        # the request URI path to the host as a subdomain, unless the request
+        # is using SSL and the bucket name contains a dot.
+        #
+        # When set to `true`, the bucket name is always forced to be part
+        # of the request URI path.  This will not work with buckets outside
+        # the classic region.
+        option(:force_path_style,
+          default: false,
+          doc_type: 'Boolean',
+          docstring: <<-DOCS)
+When set to `true`, the bucket name is always left in the
+request URI and never moved to the host as a sub-domain.
+          DOCS
+
+        def add_handlers(handlers, config)
+          handlers.add(Handler) unless config.force_path_style
+        end
+
+        # @api private
+        class Handler < Seahorse::Client::Handler
+
+          def call(context)
+            move_dns_compat_bucket_to_subdomain(context)
+            @handler.call(context)
+          end
+
+          private
+
+          def move_dns_compat_bucket_to_subdomain(context)
+            bucket_name = context.params[:bucket]
+            endpoint = context.http_request.endpoint
+            if
+              bucket_name &&
+              BucketDns.dns_compatible?(bucket_name, https?(endpoint)) &&
+              context.operation_name != 'get_bucket_location'
+            then
+              move_bucket_to_subdomain(bucket_name, endpoint)
+            end
+          end
+
+          def move_bucket_to_subdomain(bucket_name, endpoint)
+            endpoint.host = "#{bucket_name}.#{endpoint.host}"
+            path = endpoint.path.sub("/#{bucket_name}", '')
+            path = "/#{path}" unless path.match(/^\//)
+            endpoint.path = path
+          end
+
+          def https?(uri)
+            uri.scheme == 'https'
+          end
+
+        end
+
+        class << self
+
+          # @param [String] bucket_name
+          # @param [Boolean] ssl
+          # @return [Boolean]
+          def dns_compatible?(bucket_name, ssl)
+            if valid_subdomain?(bucket_name)
+              bucket_name.match(/\./) && ssl ? false : true
+            else
+              false
+            end
+          end
+
+          private
+
+          def valid_subdomain?(bucket_name)
+            bucket_name.size < 64 &&
+            bucket_name =~ /^[a-z0-9][a-z0-9.-]+[a-z0-9]$/ &&
+            bucket_name !~ /(\d+\.){3}\d+/ &&
+            bucket_name !~ /[.-]{2}/
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/plugins/bucket_name_restrictions.rb

@@ -0,0 +1,23 @@
+module Aws
+  module S3
+    module Plugins
+      # @api private
+      class BucketNameRestrictions < Seahorse::Client::Plugin
+        class Handler < Seahorse::Client::Handler
+
+          def call(context)
+            if context.params.key?(:bucket) && context.params[:bucket].include?('/')
+              msg = ":bucket option must not contain a forward-slash (/)"
+              raise ArgumentError, msg
+            end
+            @handler.call(context)
+          end
+
+        end
+
+        handler(Handler)
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/plugins/dualstack.rb

@@ -0,0 +1,70 @@
+module Aws
+  module S3
+    module Plugins
+      # @api private
+      class Dualstack < Seahorse::Client::Plugin
+
+        option(:use_dualstack_endpoint,
+          default: false,
+          doc_type: 'Boolean',
+          docstring: <<-DOCS)
+When set to `true`, IPv6-compatible bucket endpoints will be used
+for all operations.
+          DOCS
+
+        def add_handlers(handlers, config)
+          handlers.add(OptionHandler, step: :initialize)
+          handlers.add(DualstackHandler, step: :build, priority: 0)
+        end
+
+        # @api private
+        class OptionHandler < Seahorse::Client::Handler
+          def call(context)
+            dualstack = context.params.delete(:use_dualstack_endpoint)
+            dualstack = context.config.use_dualstack_endpoint if dualstack.nil?
+            context[:use_dualstack_endpoint] = dualstack
+            @handler.call(context)
+          end
+        end
+
+        # @api private
+        class DualstackHandler < Seahorse::Client::Handler
+          def call(context)
+            apply_dualstack_endpoint(context) if use_dualstack_endpoint?(context)
+            @handler.call(context)
+          end
+
+          private
+          def apply_dualstack_endpoint(context)
+            bucket_name = context.params[:bucket]
+            region = context.config.region
+            force_path_style = context.config.force_path_style
+            dns_suffix = Aws::Partitions::EndpointProvider.dns_suffix_for(region)
+
+            if use_bucket_dns?(bucket_name, context)
+              host = "#{bucket_name}.s3.dualstack.#{region}.#{dns_suffix}"
+            else
+              host = "s3.dualstack.#{region}.#{dns_suffix}"
+            end
+            endpoint = URI.parse(context.http_request.endpoint.to_s)
+            endpoint.scheme = context.http_request.endpoint.scheme
+            endpoint.port = context.http_request.endpoint.port
+            endpoint.host = host
+            context.http_request.endpoint = endpoint.to_s
+          end
+
+          def use_bucket_dns?(bucket_name, context)
+            ssl = context.http_request.endpoint.scheme == "https"
+            bucket_name && BucketDns.dns_compatible?(bucket_name, ssl) &&
+              !context.config.force_path_style
+          end
+
+          def use_dualstack_endpoint?(context)
+            context[:use_dualstack_endpoint] && !context[:use_accelerate_endpoint]
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/plugins/expect_100_continue.rb

@@ -0,0 +1,29 @@
+module Aws
+  module S3
+    module Plugins
+      class Expect100Continue < Seahorse::Client::Plugin
+
+        def add_handlers(handlers, config)
+          if config.http_continue_timeout && config.http_continue_timeout > 0
+            handlers.add(Handler)
+          end
+        end
+
+        # @api private
+        class Handler < Seahorse::Client::Handler
+
+          def call(context)
+            if
+              context.http_request.body &&
+              context.http_request.body.size > 0
+            then
+              context.http_request.headers['expect'] = '100-continue'
+            end
+            @handler.call(context)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/plugins/get_bucket_location_fix.rb

@@ -0,0 +1,23 @@
+module Aws
+  module S3
+    module Plugins
+      class GetBucketLocationFix < Seahorse::Client::Plugin
+
+        class Handler < Seahorse::Client::Handler
+
+          def call(context)
+            @handler.call(context).on(200) do |response|
+              response.data = S3::Types::GetBucketLocationOutput.new
+              xml = context.http_response.body_contents
+              matches = xml.match(/>(.+?)<\/LocationConstraint>/)
+              response.data[:location_constraint] = matches ? matches[1] : ''
+            end
+          end
+        end
+
+        handler(Handler, priority: 60, operations: [:get_bucket_location])
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/plugins/http_200_errors.rb

@@ -0,0 +1,47 @@
+module Aws
+  module S3
+    module Plugins
+
+      # A handful of Amazon S3 operations will respond with a 200 status
+      # code but will send an error in the response body. This plugin
+      # injects a handler that will parse 200 response bodies for potential
+      # errors, allowing them to be retried.
+      # @api private
+      class Http200Errors < Seahorse::Client::Plugin
+
+        class Handler < Seahorse::Client::Handler
+
+          def call(context)
+            @handler.call(context).on(200) do |response|
+              if error = check_for_error(context)
+                context.http_response.status_code = 500
+                response.data = nil
+                response.error = error
+              end
+            end
+          end
+
+          def check_for_error(context)
+            xml = context.http_response.body_contents
+            if xml.match(/<Error>/)
+              error_code = xml.match(/<Code>(.+?)<\/Code>/)[1]
+              error_message = xml.match(/<Message>(.+?)<\/Message>/)[1]
+              S3::Errors.error_class(error_code).new(context, error_message)
+            end
+          end
+
+        end
+
+        handler(Handler,
+          step: :sign,
+          operations: [
+            :complete_multipart_upload,
+            :copy_object,
+            :upload_part_copy,
+          ]
+        )
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/plugins/location_constraint.rb

@@ -0,0 +1,33 @@
+module Aws
+  module S3
+    module Plugins
+
+      # When making calls to {S3::Client#create_bucket} outside the
+      # "classic" region, the bucket location constraint must be specified.
+      # This plugin auto populates the constraint to the configured region.
+      class LocationConstraint < Seahorse::Client::Plugin
+
+        class Handler < Seahorse::Client::Handler
+
+          def call(context)
+            unless context.config.region == 'us-east-1'
+              populate_location_constraint(context.params, context.config.region)
+            end
+            @handler.call(context)
+          end
+
+          private
+
+          def populate_location_constraint(params, region)
+            params[:create_bucket_configuration] ||= {}
+            params[:create_bucket_configuration][:location_constraint] ||= region
+          end
+
+        end
+
+        handler(Handler, step: :initialize, operations: [:create_bucket])
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/plugins/md5s.rb

@@ -0,0 +1,79 @@
+require 'openssl'
+require 'base64'
+
+module Aws
+  module S3
+    module Plugins
+      class Md5s < Seahorse::Client::Plugin
+
+        # Amazon S3 requires these operations to have an MD5 checksum
+        REQUIRED_OPERATIONS = [
+          :delete_objects,
+          :put_bucket_cors,
+          :put_bucket_lifecycle,
+          :put_bucket_policy,
+          :put_bucket_tagging,
+        ]
+
+        # @api private
+        class Handler < Seahorse::Client::Handler
+
+          CHUNK_SIZE = 1 * 1024 * 1024 # one MB
+
+          def call(context)
+            body = context.http_request.body
+            if body.size > 0
+              context.http_request.headers['Content-Md5'] ||= md5(body)
+            end
+            @handler.call(context)
+          end
+
+          private
+
+          # @param [File, Tempfile, IO#read, String] value
+          # @return [String<MD5>]
+          def md5(value)
+            if (File === value || Tempfile === value) && !value.path.nil? && File.exist?(value.path)
+              Base64.encode64(OpenSSL::Digest::MD5.file(value).digest).strip
+            elsif value.respond_to?(:read)
+              md5 = OpenSSL::Digest::MD5.new
+              update_in_chunks(md5, value)
+              Base64.encode64(md5.digest).strip
+            else
+              Base64.encode64(OpenSSL::Digest::MD5.digest(value)).strip
+            end
+          end
+
+          def update_in_chunks(digest, io)
+            while chunk = io.read(CHUNK_SIZE)
+              digest.update(chunk)
+            end
+            io.rewind
+          end
+
+        end
+
+        option(:compute_checksums,
+          default: true,
+          doc_type: 'Boolean',
+          docstring: <<-DOCS)
+When `true` a MD5 checksum will be computed for every request that
+sends a body.  When `false`, MD5 checksums will only be computed
+for operations that require them.  Checksum errors returned by Amazon
+S3 are automatically retried up to `:retry_limit` times.
+          DOCS
+
+        def add_handlers(handlers, config)
+          # priority set low to ensure md5 is computed AFTER the request is
+          # built but before it is signed
+          handlers.add(Handler, {
+            priority: 10,
+            step: :build,
+            operations: config.compute_checksums ? nil : REQUIRED_OPERATIONS,
+          })
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/plugins/redirects.rb

@@ -0,0 +1,41 @@
+module Aws
+  module S3
+    module Plugins
+      class Redirects < Seahorse::Client::Plugin
+
+        option(:follow_redirects,
+          default: true,
+          doc_type: 'Boolean',
+          docstring: <<-DOCS)
+When `true`, this client will follow 307 redirects returned
+by Amazon S3.
+          DOCS
+
+        # @api private
+        class Handler < Seahorse::Client::Handler
+
+          def call(context)
+            response = @handler.call(context)
+            if context.http_response.status_code == 307
+              endpoint = context.http_response.headers['location']
+              context.http_request.endpoint = endpoint
+              context.http_response.body.truncate(0)
+              @handler.call(context)
+            else
+              response
+            end
+          end
+
+        end
+
+        def add_handlers(handlers, config)
+          if config.follow_redirects
+            # we want to re-trigger request signing
+            handlers.add(Handler, step: :sign, priority: 90)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/plugins/s3_signer.rb

@@ -0,0 +1,208 @@
+require 'aws-sigv4'
+
+module Aws
+  module S3
+    module Plugins
+      # This plugin is an implementation detail and may be modified.
+      # @api private
+      class S3Signer < Seahorse::Client::Plugin
+
+        option(:signature_version, 'v4')
+
+        option(:sigv4_signer) do |cfg|
+          S3Signer.build_v4_signer(
+            region: cfg.sigv4_region,
+            credentials: cfg.credentials
+          )
+        end
+
+        option(:sigv4_region) do |cfg|
+          Aws::Partitions::EndpointProvider.signing_region(cfg.region, 's3')
+        end
+
+        def add_handlers(handlers, cfg)
+          case cfg.signature_version
+          when 'v4' then add_v4_handlers(handlers)
+          when 's3' then add_legacy_handler(handlers)
+          else
+            msg = "unsupported signature version `#{cfg.signature_version}'"
+            raise ArgumentError, msg
+          end
+        end
+
+        def add_v4_handlers(handlers)
+          handlers.add(CachedBucketRegionHandler, step: :sign, priority: 60)
+          handlers.add(V4Handler, step: :sign)
+          handlers.add(BucketRegionErrorHandler, step: :sign, priority: 40)
+        end
+
+        def add_legacy_handler(handlers)
+          handlers.add(LegacyHandler, step: :sign)
+        end
+
+        class LegacyHandler < Seahorse::Client::Handler
+          def call(context)
+            LegacySigner.sign(context)
+            @handler.call(context)
+          end
+        end
+
+        class V4Handler < Seahorse::Client::Handler
+
+          def call(context)
+            Aws::Plugins::SignatureV4.apply_signature(
+              context: context,
+              signer: sigv4_signer(context)
+            )
+            @handler.call(context)
+          end
+
+          private
+
+          def sigv4_signer(context)
+            # If the client was configured with the wrong region,
+            # we have to build a new signer.
+            if
+              context[:cached_sigv4_region] &&
+              context[:cached_sigv4_region] != context.config.sigv4_signer.region
+            then
+              S3Signer.build_v4_signer(
+                region: context[:cached_sigv4_region],
+                credentials: context.config.credentials
+              )
+            else
+              context.config.sigv4_signer
+            end
+          end
+
+        end
+
+        # This handler will update the http endpoint when the bucket region
+        # is known/cached.
+        class CachedBucketRegionHandler < Seahorse::Client::Handler
+
+          def call(context)
+            bucket = context.params[:bucket]
+            check_for_cached_region(context, bucket) if bucket
+            @handler.call(context)
+          end
+
+          private
+
+          def check_for_cached_region(context, bucket)
+            cached_region = S3::BUCKET_REGIONS[bucket]
+            if cached_region && cached_region != context.config.region
+              context.http_request.endpoint.host = S3Signer.new_hostname(context, cached_region)
+              context[:cached_sigv4_region] = cached_region
+            end
+          end
+
+        end
+
+        # This handler detects when a request fails because of a mismatched bucket
+        # region. It follows up by making a request to determine the correct
+        # region, then finally a version 4 signed request against the correct
+        # regional endpoint.
+        class BucketRegionErrorHandler < Seahorse::Client::Handler
+
+          def call(context)
+            response = @handler.call(context)
+            handle_region_errors(response)
+          end
+
+          private
+
+          def handle_region_errors(response)
+            if wrong_sigv4_region?(response)
+              get_region_and_retry(response.context)
+            else
+              response
+            end
+          end
+
+          def get_region_and_retry(context)
+            actual_region = context.http_response.headers['x-amz-bucket-region']
+            actual_region ||= region_from_body(context.http_response.body_contents)
+            update_bucket_cache(context, actual_region)
+            log_warning(context, actual_region)
+            resign_with_new_region(context, actual_region)
+            @handler.call(context)
+          end
+
+          def update_bucket_cache(context, actual_region)
+            S3::BUCKET_REGIONS[context.params[:bucket]] = actual_region
+          end
+
+          def wrong_sigv4_region?(resp)
+            resp.context.http_response.status_code == 400 &&
+            (
+              resp.context.http_response.headers['x-amz-bucket-region'] ||
+              resp.context.http_response.body_contents.match(/<Region>.+?<\/Region>/)
+            )
+          end
+
+          def resign_with_new_region(context, actual_region)
+            context.http_response.body.truncate(0)
+            context.http_request.endpoint.host = S3Signer.new_hostname(context, actual_region)
+            Aws::Plugins::SignatureV4.apply_signature(
+              context: context,
+              signer: S3Signer.build_v4_signer(
+                region: actual_region,
+                credentials: context.config.credentials
+              )
+            )
+          end
+
+          def region_from_body(body)
+            region = body.match(/<Region>(.+?)<\/Region>/)[1]
+            if region.nil? || region == ""
+              raise "couldn't get region from body: #{body}"
+            else
+              region
+            end
+          end
+
+          def log_warning(context, actual_region)
+            msg = "S3 client configured for #{context.config.region.inspect} " +
+              "but the bucket #{context.params[:bucket].inspect} is in " +
+              "#{actual_region.inspect}; Please configure the proper region " +
+              "to avoid multiple unnecessary redirects and signing attempts\n"
+            if logger = context.config.logger
+              logger.warn(msg)
+            else
+              warn(msg)
+            end
+          end
+
+        end
+
+        class << self
+
+          # @option options [required, String] :region
+          # @option options [required, #credentials] :credentials
+          # @api private
+          def build_v4_signer(options = {})
+            Aws::Sigv4::Signer.new({
+              service: 's3',
+              region: options[:region],
+              credentials_provider: options[:credentials],
+              uri_escape_path: false,
+              unsigned_headers: ['content-length'],
+            })
+          end
+
+          def new_hostname(context, region)
+            bucket = context.params[:bucket]
+            if region == 'us-east-1'
+              "#{bucket}.s3.amazonaws.com"
+            else
+              endpoint = Aws::Partitions::EndpointProvider.resolve(region, 's3')
+              bucket + '.' + URI.parse(endpoint).host
+            end
+          end
+
+        end
+      end
+    end
+  end
+end