aws-sdk-s3 1.109.0 → 1.156.0

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

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/version-3/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+
+module Aws::S3
+  module Plugins
+    class Endpoints < Seahorse::Client::Plugin
+      option(
+        :endpoint_provider,
+        doc_type: 'Aws::S3::EndpointProvider',
+        rbs_type: 'untyped',
+        docstring: 'The endpoint provider used to resolve endpoints. Any '\
+                   'object that responds to `#resolve_endpoint(parameters)` '\
+                   'where `parameters` is a Struct similar to '\
+                   '`Aws::S3::EndpointParameters`'
+      ) do |cfg|
+        Aws::S3::EndpointProvider.new
+      end
+
+      option(
+        :disable_s3_express_session_auth,
+        doc_type: 'Boolean',
+        default: nil,
+        docstring: "Parameter to indicate whether S3Express session auth should be disabled")
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+        def call(context)
+          unless context[:discovered_endpoint]
+            params = parameters_for_operation(context)
+            endpoint = context.config.endpoint_provider.resolve_endpoint(params)
+
+            context.http_request.endpoint = endpoint.url
+            apply_endpoint_headers(context, endpoint.headers)
+
+            context[:endpoint_params] = params
+            context[:endpoint_properties] = endpoint.properties
+          end
+
+          context[:auth_scheme] =
+            Aws::Endpoints.resolve_auth_scheme(context, endpoint)
+
+          @handler.call(context)
+        end
+
+        private
+
+        def apply_endpoint_headers(context, headers)
+          headers.each do |key, values|
+            value = values
+              .compact
+              .map { |s| Seahorse::Util.escape_header_list_string(s.to_s) }
+              .join(',')
+
+            context.http_request.headers[key] = value
+          end
+        end
+
+        def parameters_for_operation(context)
+          case context.operation_name
+          when :abort_multipart_upload
+            Aws::S3::Endpoints::AbortMultipartUpload.build(context)
+          when :complete_multipart_upload
+            Aws::S3::Endpoints::CompleteMultipartUpload.build(context)
+          when :copy_object
+            Aws::S3::Endpoints::CopyObject.build(context)
+          when :create_bucket
+            Aws::S3::Endpoints::CreateBucket.build(context)
+          when :create_multipart_upload
+            Aws::S3::Endpoints::CreateMultipartUpload.build(context)
+          when :create_session
+            Aws::S3::Endpoints::CreateSession.build(context)
+          when :delete_bucket
+            Aws::S3::Endpoints::DeleteBucket.build(context)
+          when :delete_bucket_analytics_configuration
+            Aws::S3::Endpoints::DeleteBucketAnalyticsConfiguration.build(context)
+          when :delete_bucket_cors
+            Aws::S3::Endpoints::DeleteBucketCors.build(context)
+          when :delete_bucket_encryption
+            Aws::S3::Endpoints::DeleteBucketEncryption.build(context)
+          when :delete_bucket_intelligent_tiering_configuration
+            Aws::S3::Endpoints::DeleteBucketIntelligentTieringConfiguration.build(context)
+          when :delete_bucket_inventory_configuration
+            Aws::S3::Endpoints::DeleteBucketInventoryConfiguration.build(context)
+          when :delete_bucket_lifecycle
+            Aws::S3::Endpoints::DeleteBucketLifecycle.build(context)
+          when :delete_bucket_metrics_configuration
+            Aws::S3::Endpoints::DeleteBucketMetricsConfiguration.build(context)
+          when :delete_bucket_ownership_controls
+            Aws::S3::Endpoints::DeleteBucketOwnershipControls.build(context)
+          when :delete_bucket_policy
+            Aws::S3::Endpoints::DeleteBucketPolicy.build(context)
+          when :delete_bucket_replication
+            Aws::S3::Endpoints::DeleteBucketReplication.build(context)
+          when :delete_bucket_tagging
+            Aws::S3::Endpoints::DeleteBucketTagging.build(context)
+          when :delete_bucket_website
+            Aws::S3::Endpoints::DeleteBucketWebsite.build(context)
+          when :delete_object
+            Aws::S3::Endpoints::DeleteObject.build(context)
+          when :delete_object_tagging
+            Aws::S3::Endpoints::DeleteObjectTagging.build(context)
+          when :delete_objects
+            Aws::S3::Endpoints::DeleteObjects.build(context)
+          when :delete_public_access_block
+            Aws::S3::Endpoints::DeletePublicAccessBlock.build(context)
+          when :get_bucket_accelerate_configuration
+            Aws::S3::Endpoints::GetBucketAccelerateConfiguration.build(context)
+          when :get_bucket_acl
+            Aws::S3::Endpoints::GetBucketAcl.build(context)
+          when :get_bucket_analytics_configuration
+            Aws::S3::Endpoints::GetBucketAnalyticsConfiguration.build(context)
+          when :get_bucket_cors
+            Aws::S3::Endpoints::GetBucketCors.build(context)
+          when :get_bucket_encryption
+            Aws::S3::Endpoints::GetBucketEncryption.build(context)
+          when :get_bucket_intelligent_tiering_configuration
+            Aws::S3::Endpoints::GetBucketIntelligentTieringConfiguration.build(context)
+          when :get_bucket_inventory_configuration
+            Aws::S3::Endpoints::GetBucketInventoryConfiguration.build(context)
+          when :get_bucket_lifecycle
+            Aws::S3::Endpoints::GetBucketLifecycle.build(context)
+          when :get_bucket_lifecycle_configuration
+            Aws::S3::Endpoints::GetBucketLifecycleConfiguration.build(context)
+          when :get_bucket_location
+            Aws::S3::Endpoints::GetBucketLocation.build(context)
+          when :get_bucket_logging
+            Aws::S3::Endpoints::GetBucketLogging.build(context)
+          when :get_bucket_metrics_configuration
+            Aws::S3::Endpoints::GetBucketMetricsConfiguration.build(context)
+          when :get_bucket_notification
+            Aws::S3::Endpoints::GetBucketNotification.build(context)
+          when :get_bucket_notification_configuration
+            Aws::S3::Endpoints::GetBucketNotificationConfiguration.build(context)
+          when :get_bucket_ownership_controls
+            Aws::S3::Endpoints::GetBucketOwnershipControls.build(context)
+          when :get_bucket_policy
+            Aws::S3::Endpoints::GetBucketPolicy.build(context)
+          when :get_bucket_policy_status
+            Aws::S3::Endpoints::GetBucketPolicyStatus.build(context)
+          when :get_bucket_replication
+            Aws::S3::Endpoints::GetBucketReplication.build(context)
+          when :get_bucket_request_payment
+            Aws::S3::Endpoints::GetBucketRequestPayment.build(context)
+          when :get_bucket_tagging
+            Aws::S3::Endpoints::GetBucketTagging.build(context)
+          when :get_bucket_versioning
+            Aws::S3::Endpoints::GetBucketVersioning.build(context)
+          when :get_bucket_website
+            Aws::S3::Endpoints::GetBucketWebsite.build(context)
+          when :get_object
+            Aws::S3::Endpoints::GetObject.build(context)
+          when :get_object_acl
+            Aws::S3::Endpoints::GetObjectAcl.build(context)
+          when :get_object_attributes
+            Aws::S3::Endpoints::GetObjectAttributes.build(context)
+          when :get_object_legal_hold
+            Aws::S3::Endpoints::GetObjectLegalHold.build(context)
+          when :get_object_lock_configuration
+            Aws::S3::Endpoints::GetObjectLockConfiguration.build(context)
+          when :get_object_retention
+            Aws::S3::Endpoints::GetObjectRetention.build(context)
+          when :get_object_tagging
+            Aws::S3::Endpoints::GetObjectTagging.build(context)
+          when :get_object_torrent
+            Aws::S3::Endpoints::GetObjectTorrent.build(context)
+          when :get_public_access_block
+            Aws::S3::Endpoints::GetPublicAccessBlock.build(context)
+          when :head_bucket
+            Aws::S3::Endpoints::HeadBucket.build(context)
+          when :head_object
+            Aws::S3::Endpoints::HeadObject.build(context)
+          when :list_bucket_analytics_configurations
+            Aws::S3::Endpoints::ListBucketAnalyticsConfigurations.build(context)
+          when :list_bucket_intelligent_tiering_configurations
+            Aws::S3::Endpoints::ListBucketIntelligentTieringConfigurations.build(context)
+          when :list_bucket_inventory_configurations
+            Aws::S3::Endpoints::ListBucketInventoryConfigurations.build(context)
+          when :list_bucket_metrics_configurations
+            Aws::S3::Endpoints::ListBucketMetricsConfigurations.build(context)
+          when :list_buckets
+            Aws::S3::Endpoints::ListBuckets.build(context)
+          when :list_directory_buckets
+            Aws::S3::Endpoints::ListDirectoryBuckets.build(context)
+          when :list_multipart_uploads
+            Aws::S3::Endpoints::ListMultipartUploads.build(context)
+          when :list_object_versions
+            Aws::S3::Endpoints::ListObjectVersions.build(context)
+          when :list_objects
+            Aws::S3::Endpoints::ListObjects.build(context)
+          when :list_objects_v2
+            Aws::S3::Endpoints::ListObjectsV2.build(context)
+          when :list_parts
+            Aws::S3::Endpoints::ListParts.build(context)
+          when :put_bucket_accelerate_configuration
+            Aws::S3::Endpoints::PutBucketAccelerateConfiguration.build(context)
+          when :put_bucket_acl
+            Aws::S3::Endpoints::PutBucketAcl.build(context)
+          when :put_bucket_analytics_configuration
+            Aws::S3::Endpoints::PutBucketAnalyticsConfiguration.build(context)
+          when :put_bucket_cors
+            Aws::S3::Endpoints::PutBucketCors.build(context)
+          when :put_bucket_encryption
+            Aws::S3::Endpoints::PutBucketEncryption.build(context)
+          when :put_bucket_intelligent_tiering_configuration
+            Aws::S3::Endpoints::PutBucketIntelligentTieringConfiguration.build(context)
+          when :put_bucket_inventory_configuration
+            Aws::S3::Endpoints::PutBucketInventoryConfiguration.build(context)
+          when :put_bucket_lifecycle
+            Aws::S3::Endpoints::PutBucketLifecycle.build(context)
+          when :put_bucket_lifecycle_configuration
+            Aws::S3::Endpoints::PutBucketLifecycleConfiguration.build(context)
+          when :put_bucket_logging
+            Aws::S3::Endpoints::PutBucketLogging.build(context)
+          when :put_bucket_metrics_configuration
+            Aws::S3::Endpoints::PutBucketMetricsConfiguration.build(context)
+          when :put_bucket_notification
+            Aws::S3::Endpoints::PutBucketNotification.build(context)
+          when :put_bucket_notification_configuration
+            Aws::S3::Endpoints::PutBucketNotificationConfiguration.build(context)
+          when :put_bucket_ownership_controls
+            Aws::S3::Endpoints::PutBucketOwnershipControls.build(context)
+          when :put_bucket_policy
+            Aws::S3::Endpoints::PutBucketPolicy.build(context)
+          when :put_bucket_replication
+            Aws::S3::Endpoints::PutBucketReplication.build(context)
+          when :put_bucket_request_payment
+            Aws::S3::Endpoints::PutBucketRequestPayment.build(context)
+          when :put_bucket_tagging
+            Aws::S3::Endpoints::PutBucketTagging.build(context)
+          when :put_bucket_versioning
+            Aws::S3::Endpoints::PutBucketVersioning.build(context)
+          when :put_bucket_website
+            Aws::S3::Endpoints::PutBucketWebsite.build(context)
+          when :put_object
+            Aws::S3::Endpoints::PutObject.build(context)
+          when :put_object_acl
+            Aws::S3::Endpoints::PutObjectAcl.build(context)
+          when :put_object_legal_hold
+            Aws::S3::Endpoints::PutObjectLegalHold.build(context)
+          when :put_object_lock_configuration
+            Aws::S3::Endpoints::PutObjectLockConfiguration.build(context)
+          when :put_object_retention
+            Aws::S3::Endpoints::PutObjectRetention.build(context)
+          when :put_object_tagging
+            Aws::S3::Endpoints::PutObjectTagging.build(context)
+          when :put_public_access_block
+            Aws::S3::Endpoints::PutPublicAccessBlock.build(context)
+          when :restore_object
+            Aws::S3::Endpoints::RestoreObject.build(context)
+          when :select_object_content
+            Aws::S3::Endpoints::SelectObjectContent.build(context)
+          when :upload_part
+            Aws::S3::Endpoints::UploadPart.build(context)
+          when :upload_part_copy
+            Aws::S3::Endpoints::UploadPartCopy.build(context)
+          when :write_get_object_response
+            Aws::S3::Endpoints::WriteGetObjectResponse.build(context)
+          end
+        end
+      end
+
+      def add_handlers(handlers, _config)
+        handlers.add(Handler, step: :build, priority: 75)
+      end
+    end
+  end
+end

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

@@ -16,7 +16,8 @@ module Aws
 
           def call(context)
             body = context.http_request.body
-            if body.respond_to?(:size) && body.size > 0
+            if body.respond_to?(:size) && body.size > 0 &&
+               !context[:use_accelerate_endpoint]
               context.http_request.headers['expect'] = '100-continue'
             end
             @handler.call(context)

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Aws
+  module S3
+    module Plugins
+      # @api private
+      class ExpressSessionAuth < Seahorse::Client::Plugin
+        # This should be s3_disable_express_auth instead
+        # But this is not a built in. We're overwriting the generated value
+        option(:disable_s3_express_session_auth,
+          default: false,
+          doc_type: 'Boolean',
+          docstring: <<-DOCS) do |cfg|
+When `true`, S3 Express session authentication is disabled.
+          DOCS
+          resolve_disable_s3_express_session_auth(cfg)
+        end
+
+        option(:express_credentials_provider,
+          doc_type: 'Aws::S3::ExpressCredentialsProvider',
+          rbs_type: 'untyped',
+          docstring: <<-DOCS) do |_cfg|
+Credential Provider for S3 Express endpoints. Manages credentials
+for different buckets.
+          DOCS
+          Aws::S3::ExpressCredentialsProvider.new
+        end
+
+        # @api private
+        class Handler < Seahorse::Client::Handler
+          def call(context)
+            if (props = context[:endpoint_properties])
+              # S3 Express endpoint - turn off md5 and enable crc32 default
+              if props['backend'] == 'S3Express'
+                if context.operation_name == :put_object || checksum_required?(context)
+                  context[:default_request_checksum_algorithm] = 'CRC32'
+                end
+                context[:s3_express_endpoint] = true
+              end
+
+              # if s3 express auth, use new credentials and sign additional header
+              if context[:auth_scheme]['name'] == 'sigv4-s3express' &&
+                 !context.config.disable_s3_express_session_auth
+                bucket = context.params[:bucket]
+                credentials_provider = context.config.express_credentials_provider
+                credentials = credentials_provider.express_credentials_for(bucket)
+                context[:sigv4_credentials] = credentials # Sign will use this
+              end
+            end
+            with_metric(credentials) { @handler.call(context) }
+          end
+
+          private
+
+          def with_metric(credentials, &block)
+            return block.call unless credentials
+
+            Aws::Plugins::UserAgent.metric('S3_EXPRESS_BUCKET', &block)
+          end
+
+          def checksum_required?(context)
+            context.operation.http_checksum_required ||
+              (context.operation.http_checksum &&
+                context.operation.http_checksum['requestChecksumRequired'])
+          end
+        end
+
+        handler(Handler)
+
+        # Optimization - sets this client as the client to create sessions.
+        def after_initialize(client)
+          provider = client.config.express_credentials_provider
+          provider.client = client unless provider.client
+        end
+
+        class << self
+          private
+
+          def resolve_disable_s3_express_session_auth(cfg)
+            value = ENV['AWS_S3_DISABLE_EXPRESS_SESSION_AUTH'] ||
+                    Aws.shared_config.s3_disable_express_session_auth(profile: cfg.profile) ||
+                    'false'
+            value = Aws::Util.str_2_bool(value)
+            # Raise if provided value is not true or false
+            if value.nil?
+              raise ArgumentError,
+                    'Must provide either `true` or `false` for the '\
+                    '`s3_disable_express_session_auth` profile option or for '\
+                    "ENV['AWS_S3_DISABLE_EXPRESS_SESSION_AUTH']."
+            end
+            value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -15,22 +15,67 @@ module Aws
 
           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
+              return response if streaming_output?(context.operation.output)
+
+              error = check_for_error(context)
+              return response unless error
+
+              context.http_response.status_code = 500
+              response.data = nil
+              response.error = error
+            end
+          end
+
+          private
+
+          # Streaming outputs are not subject to 200 errors.
+          def streaming_output?(output)
+            if (payload = output[:payload_member])
+              # checking ref and shape
+              payload['streaming'] || payload.shape['streaming'] ||
+                payload.eventstream
+            else
+              false
+            end
+          end
+
+          # Checks if the output shape is a structure shape and has members that
+          # are in the body for the case of a payload and a normal structure. A
+          # non-structure shape will not have members in the body. In the case
+          # of a string or blob, the body contents would have been checked first
+          # before this method is called in incomplete_xml_body?.
+          def members_in_body?(output)
+            shape =
+              if output[:payload_member]
+                output[:payload_member].shape
+              else
+                output.shape
               end
+
+            if structure_shape?(shape)
+              shape.members.any? { |_, k| k.location.nil? }
+            else
+              false
             end
           end
 
+          def structure_shape?(shape)
+            shape.is_a?(Seahorse::Model::Shapes::StructureShape)
+          end
+
+          # Must have a member in the body and have the start of an XML Tag.
+          # Other incomplete xml bodies will result in an XML ParsingError.
+          def incomplete_xml_body?(xml, output)
+            members_in_body?(output) && !xml.match(/<\w/)
+          end
+
           def check_for_error(context)
             xml = context.http_response.body_contents
-            if xml.match(/<Error>/)
+            if xml.match(/\?>\s*<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)
-            elsif !xml.match(/<\w/) # Must have the start of an XML Tag
-              # Other incomplete xml bodies will result in XML ParsingError
+            elsif incomplete_xml_body?(xml, context.operation.output)
               Seahorse::Client::NetworkingError.new(
                 S3::Errors
                   .error_class('InternalError')
@@ -40,15 +85,7 @@ module Aws
           end
         end
 
-        handler(
-          Handler,
-          step: :sign,
-          operations: [
-            :complete_multipart_upload,
-            :copy_object,
-            :upload_part_copy,
-          ]
-        )
+        handler(Handler, step: :sign)
       end
     end
   end

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

@@ -16,40 +16,17 @@ Defaults to `legacy` mode which uses the global endpoint.
           resolve_iad_regional_endpoint(cfg)
         end
 
-        def add_handlers(handlers, config)
-          # only modify non-custom endpoints
-          if config.regional_endpoint && config.region == 'us-east-1'
-            handlers.add(Handler)
-          end
-        end
-
-        # @api private
-        class Handler < Seahorse::Client::Handler
-
-          def call(context)
-            # WriteGetObjectResponse does not have a global endpoint
-            # ARNs are regionalized, so don't touch those either.
-            if context.operation.name != 'WriteGetObjectResponse' &&
-               context.config.s3_us_east_1_regional_endpoint == 'legacy' &&
-               !context.metadata[:s3_arn]
-              host = context.http_request.endpoint.host
-              legacy_host = IADRegionalEndpoint.legacy_host(host)
-              context.http_request.endpoint.host = legacy_host
-            end
-            @handler.call(context)
-          end
-
-        end
-
-        def self.legacy_host(host)
-          host.sub(".us-east-1", '')
-        end
-
         private
 
         def self.resolve_iad_regional_endpoint(cfg)
+          default_mode_value =
+            if cfg.respond_to?(:defaults_mode_config_resolver)
+              cfg.defaults_mode_config_resolver.resolve(:s3_us_east_1_regional_endpoint)
+            end
+
           mode = ENV['AWS_S3_US_EAST_1_REGIONAL_ENDPOINT'] ||
             Aws.shared_config.s3_us_east_1_regional_endpoint(profile: cfg.profile) ||
+            default_mode_value ||
             'legacy'
           mode = mode.downcase
           unless %w(legacy regional).include?(mode)

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

@@ -22,7 +22,9 @@ module Aws
 
           def populate_location_constraint(params, region)
             params[:create_bucket_configuration] ||= {}
-            params[:create_bucket_configuration][:location_constraint] ||= region
+            unless params[:create_bucket_configuration][:location]
+              params[:create_bucket_configuration][:location_constraint] ||= region
+            end
           end
 
         end

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

@@ -22,9 +22,12 @@ module Aws
           CHUNK_SIZE = 1 * 1024 * 1024 # one MB
 
           def call(context)
-            body = context.http_request.body
-            if body.respond_to?(:size) && body.size > 0
-              context.http_request.headers['Content-Md5'] ||= md5(body)
+            if !context[:checksum_algorithms] && # skip in favor of flexible checksum
+               !context[:s3_express_endpoint] # s3 express endpoints do not support md5
+              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