aws-sdk-s3 1.48.0 → 1.113.0

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

@@ -1,21 +1,19 @@
+# frozen_string_literal: true
+
 require 'openssl'
-require 'base64'
 
 module Aws
   module S3
     module Plugins
+      # @api private
+      # This plugin is effectively deprecated in favor of modeled
+      # httpChecksumRequired traits.
       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,
-          :put_object_legal_hold,
-          :put_object_lock_configuration,
-          :put_object_retention
+        # These operations allow Content MD5 but are not required by
+        # httpChecksumRequired. This list should not grow.
+        OPTIONAL_OPERATIONS = [
+          :put_object,
+          :upload_part
         ]
 
         # @api private
@@ -24,9 +22,11 @@ module Aws
           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)
+            if !context[:checksum_algorithms] # skip in favor of flexible checksum
+              body = context.http_request.body
+              if body.respond_to?(:size) && body.size > 0
+                context.http_request.headers['Content-Md5'] ||= md5(body)
+              end
             end
             @handler.call(context)
           end
@@ -37,18 +37,20 @@ module Aws
           # @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
+              OpenSSL::Digest::MD5.file(value).base64digest
             elsif value.respond_to?(:read)
               md5 = OpenSSL::Digest::MD5.new
               update_in_chunks(md5, value)
-              Base64.encode64(md5.digest).strip
+              md5.base64digest
             else
-              Base64.encode64(OpenSSL::Digest::MD5.digest(value)).strip
+              OpenSSL::Digest::MD5.digest(value).base64digest
             end
           end
 
           def update_in_chunks(digest, io)
-            while chunk = io.read(CHUNK_SIZE, buffer ||= "")
+            loop do
+              chunk = io.read(CHUNK_SIZE)
+              break unless chunk
               digest.update(chunk)
             end
             io.rewind
@@ -60,20 +62,22 @@ module Aws
           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.
+When `true` a MD5 checksum will be computed and sent in the Content Md5
+header for :put_object and :upload_part. When `false`, MD5 checksums
+will not be computed for these operations. Checksums are still computed
+for operations requiring 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,
-          })
+          if config.compute_checksums
+            # 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: OPTIONAL_OPERATIONS
+            )
+          end
         end
 
       end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Aws
+  module S3
+    module Plugins
+      # WriteGetObjectResponse is called from Lambda after a data transform.
+      # If there is no custom endpoint, we change the endpoint from s3 to
+      # s3-object-lambda just for this operation.
+      class ObjectLambdaEndpoint < Seahorse::Client::Plugin
+        class Handler < Seahorse::Client::Handler
+          def call(context)
+            if context.config.regional_endpoint
+              host = context.http_request.endpoint.host
+              host = host.sub('s3.', 's3-object-lambda.')
+              context.http_request.endpoint.host = host
+            end
+            @handler.call(context)
+          end
+        end
+
+        handler(Handler, operations: [:write_get_object_response])
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module S3
     module Plugins

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module S3
     module Plugins

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aws-sigv4'
 
 module Aws
@@ -6,18 +8,23 @@ module Aws
       # 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(
+            service: 's3',
             region: cfg.sigv4_region,
             credentials: cfg.credentials
           )
         end
 
         option(:sigv4_region) do |cfg|
-          Aws::Partitions::EndpointProvider.signing_region(cfg.region, 's3')
+          # S3 removes core's signature_v4 plugin that checks for this
+          raise Aws::Errors::MissingRegionError if cfg.region.nil?
+
+          Aws::Partitions::EndpointProvider.signing_region(
+            cfg.region, 's3'
+          )
         end
 
         def add_handlers(handlers, cfg)
@@ -48,7 +55,6 @@ module Aws
         end
 
         class V4Handler < Seahorse::Client::Handler
-
           def call(context)
             Aws::Plugins::SignatureV4.apply_signature(
               context: context,
@@ -62,25 +68,42 @@ module Aws
           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
+            if context[:cached_sigv4_region] &&
+               context[:cached_sigv4_region] != context.config.sigv4_signer.region
               S3Signer.build_v4_signer(
+                service: 's3',
                 region: context[:cached_sigv4_region],
                 credentials: context.config.credentials
               )
+            elsif (arn = context.metadata[:s3_arn])
+              if arn[:arn].is_a?(MultiRegionAccessPointARN)
+                signing_region = '*'
+                signing_algorithm = :sigv4a
+              else
+                signing_region = arn[:resolved_region]
+                signing_algorithm = :sigv4
+              end
+              S3Signer.build_v4_signer(
+                service: arn[:arn].service,
+                signing_algorithm: signing_algorithm,
+                region: signing_region,
+                credentials: context.config.credentials
+              )
+            elsif context.operation.name == 'WriteGetObjectResponse'
+              S3Signer.build_v4_signer(
+                service: 's3-object-lambda',
+                region: context.config.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
@@ -92,11 +115,12 @@ module Aws
           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.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
@@ -104,7 +128,6 @@ module Aws
         # 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)
@@ -113,7 +136,9 @@ module Aws
           private
 
           def handle_region_errors(response)
-            if wrong_sigv4_region?(response) && !fips_region?(response)
+            if wrong_sigv4_region?(response) &&
+               !fips_region?(response) &&
+               !custom_endpoint?(response)
               get_region_and_retry(response.context)
             else
               response
@@ -137,21 +162,38 @@ module Aws
             resp.context.http_request.endpoint.host.include?('fips')
           end
 
+          def custom_endpoint?(resp)
+            resolved_suffix = Aws::Partitions::EndpointProvider.dns_suffix_for(
+              resp.context.config.region,
+              's3',
+              {
+                dualstack: resp.context[:use_dualstack_endpoint],
+                fips: resp.context.config.use_fips_endpoint
+              }
+            )
+            !resp.context.http_request.endpoint.hostname.include?(resolved_suffix)
+          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>/)
-            )
+              (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)
+            context.http_request.endpoint.host = S3Signer.new_hostname(
+              context, actual_region
+            )
             context.metadata[:redirect_region] = actual_region
+            # if it's an ARN, use the service in the ARN
+            if (arn = context.metadata[:s3_arn])
+              service = arn[:arn].service
+            end
             Aws::Plugins::SignatureV4.apply_signature(
               context: context,
               signer: S3Signer.build_v4_signer(
+                service: service || 's3',
                 region: actual_region,
                 credentials: context.config.credentials
               )
@@ -160,7 +202,7 @@ module Aws
 
           def region_from_body(body)
             region = body.match(/<Region>(.+?)<\/Region>/)[1]
-            if region.nil? || region == ""
+            if region.nil? || region == ''
               raise "couldn't get region from body: #{body}"
             else
               region
@@ -168,44 +210,55 @@ module Aws
           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
+            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',
+            Aws::Sigv4::Signer.new(
+              service: options[:service],
               region: options[:region],
               credentials_provider: options[:credentials],
+              signing_algorithm: options.fetch(:signing_algorithm, :sigv4),
               uri_escape_path: false,
-              unsigned_headers: ['content-length', 'x-amzn-trace-id'],
-            })
+              unsigned_headers: ['content-length', 'x-amzn-trace-id']
+            )
           end
 
+          # Check to see if the bucket is actually an ARN
+          # Otherwise it will retry with the ARN as the bucket name.
           def new_hostname(context, region)
-            bucket = context.params[:bucket]
-            if region == 'us-east-1'
-              "#{bucket}.s3.amazonaws.com"
+            uri = URI.parse(
+              Aws::Partitions::EndpointProvider.resolve(
+                region, 's3', 'regional',
+                {
+                  dualstack: context[:use_dualstack_endpoint],
+                  fips: context.config.use_fips_endpoint
+                }
+              )
+            )
+
+            if (arn = context.metadata[:s3_arn])
+              # Retry with the response region and not the ARN resolved one
+              ARN.resolve_url!(
+                uri, arn[:arn], region, arn[:fips], arn[:dualstack]
+              ).host
             else
-              endpoint = Aws::Partitions::EndpointProvider.resolve(region, 's3')
-              bucket + '.' + URI.parse(endpoint).host
+              "#{context.params[:bucket]}.#{uri.host}"
             end
           end
-
         end
       end
     end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Aws
+  module S3
+    module Plugins
+
+      # S3 GetObject results for whole Multipart Objects contain a checksum
+      # that cannot be validated.  These should be skipped by the
+      # ChecksumAlgorithm plugin.
+      class SkipWholeMultipartGetChecksums < Seahorse::Client::Plugin
+
+        class Handler < Seahorse::Client::Handler
+
+          def call(context)
+            context[:http_checksum] ||= {}
+            context[:http_checksum][:skip_on_suffix] = true
+
+            @handler.call(context)
+          end
+
+        end
+
+        handler(
+          Handler,
+          step: :initialize,
+          operations: [:get_object]
+        )
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'uri'
 require 'openssl'
 
@@ -18,7 +20,7 @@ This should only be disabled for local testing.
         class Handler < Seahorse::Client::Handler
 
           def call(context)
-            compute_key_md5(context)
+            compute_key_md5(context) if context.params.is_a?(Hash)
             @handler.call(context)
           end
 

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Aws
+  module S3
+    module Plugins
+
+      # A wrapper around BlockIO that adds no-ops for truncate and rewind
+      # @api private
+      class RetryableBlockIO
+        extend Forwardable
+        def_delegators :@block_io, :write, :read, :size
+
+        def initialize(block_io)
+          @block_io = block_io
+        end
+
+        def truncate(_integer); end
+
+        def rewind; end
+      end
+
+      # A wrapper around ManagedFile that adds no-ops for truncate and rewind
+      # @api private
+      class RetryableManagedFile
+        extend Forwardable
+        def_delegators :@file, :write, :read, :size, :open?, :close
+
+        def initialize(managed_file)
+          @file = managed_file
+        end
+
+        def truncate(_integer); end
+
+        def rewind; end
+      end
+
+      # This handler works with the ResponseTarget plugin to provide smart
+      # retries of S3 streaming operations that support the range parameter
+      # (currently only: get_object).  When a 200 OK with a TruncatedBodyError
+      # is received this handler will add a range header that excludes the
+      # data that has already been processed (written to file or sent to
+      # the target Proc).
+      # It is important to not write data to the custom target in the case of
+      # a non-success response. We do not want to write an XML error
+      # message to someone's file or pass it to a user's Proc.
+      # @api private
+      class StreamingRetry < Seahorse::Client::Plugin
+
+        class Handler < Seahorse::Client::Handler
+
+          def call(context)
+            target = context.params[:response_target] || context[:response_target]
+
+            # retry is only supported when range is NOT set on the initial request
+            if supported_target?(target) && !context.params[:range]
+              add_event_listeners(context, target)
+            end
+            @handler.call(context)
+          end
+
+          private
+
+          def add_event_listeners(context, target)
+            context.http_response.on_headers(200..299) do
+              case context.http_response.body
+              when Seahorse::Client::BlockIO then
+                context.http_response.body = RetryableBlockIO.new(context.http_response.body)
+              when Seahorse::Client::ManagedFile then
+                context.http_response.body = RetryableManagedFile.new(context.http_response.body)
+              end
+            end
+
+            context.http_response.on_headers(400..599) do
+              context.http_response.body = StringIO.new # something to write the error to
+            end
+
+            context.http_response.on_success(200..299) do
+              body = context.http_response.body
+              if body.is_a?(RetryableManagedFile) && body.open?
+                body.close
+              end
+            end
+
+            context.http_response.on_error do |error|
+              if retryable_body?(context) && truncated_body?(error)
+                context.http_request.headers[:range] = "bytes=#{context.http_response.body.size}-"
+              end
+            end
+          end
+
+          def truncated_body?(error)
+            error.is_a?(Seahorse::Client::NetworkingError) &&
+              error.original_error.is_a?(
+                Seahorse::Client::NetHttp::Handler::TruncatedBodyError
+              )
+          end
+
+          def retryable_body?(context)
+            context.http_response.body.is_a?(RetryableBlockIO) ||
+              context.http_response.body.is_a?(RetryableManagedFile)
+          end
+
+          def supported_target?(target)
+            case target
+            when Proc, String, Pathname then true
+            else false
+            end
+          end
+        end
+
+        handler(Handler, step: :sign, operations: [:get_object], priority: 10)
+
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'uri'
 require 'cgi'