aws-sdk-s3 1.103.0 → 1.120.0

data/lib/aws-sdk-s3/customizations/bucket.rb

@@ -5,22 +5,6 @@ require 'uri'
 module Aws
   module S3
     class Bucket
-      # Save the old initialize method so that we can call 'super'.
-      old_initialize = instance_method(:initialize)
-      # Make the method redefinable
-      alias_method :initialize, :initialize
-      # Define a new initialize method that extracts out a bucket ARN.
-      define_method(:initialize) do |*args|
-        old_initialize.bind(self).call(*args)
-        resolved_region, arn = Plugins::ARN.resolve_arn!(
-          name,
-          client.config.region,
-          client.config.s3_use_arn_region
-        )
-        @resolved_region = resolved_region
-        @arn = arn
-      end
-
       # Deletes all objects and versioned objects from this bucket
       #
       # @example
@@ -105,14 +89,27 @@ module Aws
         if options[:virtual_host]
           scheme = options.fetch(:secure, true) ? 'https' : 'http'
           "#{scheme}://#{name}"
-        elsif @arn
-          Plugins::ARN.resolve_url!(
-            client.config.endpoint.dup,
-            @arn,
-            @resolved_region
-          ).to_s
         else
-          s3_bucket_url
+          # Taken from Aws::S3::Endpoints module
+          unless client.config.regional_endpoint
+            endpoint = client.config.endpoint.to_s
+          end
+          params = Aws::S3::EndpointParameters.new(
+            bucket: name,
+            region: client.config.region,
+            use_fips: client.config.use_fips_endpoint,
+            use_dual_stack: client.config.use_dualstack_endpoint,
+            endpoint: endpoint,
+            force_path_style: client.config.force_path_style,
+            accelerate: client.config.use_accelerate_endpoint,
+            use_global_endpoint: client.config.s3_us_east_1_regional_endpoint == 'legacy',
+            use_object_lambda_endpoint: nil,
+            disable_access_points: nil,
+            disable_multi_region_access_points: client.config.s3_disable_multiregion_access_points,
+            use_arn_region: client.config.s3_use_arn_region,
+          )
+          endpoint = Aws::S3::EndpointProvider.new.resolve_endpoint(params)
+          endpoint.url
         end
       end
 
@@ -142,29 +139,6 @@ module Aws
 
         self
       end
-
-      private
-
-      def s3_bucket_url
-        url = client.config.endpoint.dup
-        if bucket_as_hostname?(url.scheme == 'https')
-          url.host = "#{name}.#{url.host}"
-        else
-          url.path += '/' unless url.path[-1] == '/'
-          url.path += Seahorse::Util.uri_escape(name)
-        end
-        if (client.config.region == 'us-east-1') &&
-           (client.config.s3_us_east_1_regional_endpoint == 'legacy')
-          url.host = Plugins::IADRegionalEndpoint.legacy_host(url.host)
-        end
-        url.to_s
-      end
-
-      def bucket_as_hostname?(https)
-        Plugins::BucketDns.dns_compatible?(name, https) &&
-          !client.config.force_path_style
-      end
-
     end
   end
 end

data/lib/aws-sdk-s3/customizations/errors.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Aws
+  module S3
+    module Errors
+      # Hijack PermanentRedirect dynamic error to also include endpoint
+      # and bucket.
+      class PermanentRedirect < ServiceError
+        # @param [Seahorse::Client::RequestContext] context
+        # @param [String] message
+        # @param [Aws::S3::Types::PermanentRedirect] data
+        def initialize(context, message, _data = Aws::EmptyStructure.new)
+          data = Aws::S3::Types::PermanentRedirect.new(message: message)
+          body = context.http_response.body_contents
+          if (endpoint = body.match(/<Endpoint>(.+?)<\/Endpoint>/))
+            data.endpoint = endpoint[1]
+          end
+          if (bucket = body.match(/<Bucket>(.+?)<\/Bucket>/))
+            data.bucket = bucket[1]
+          end
+          data.region = context.http_response.headers['x-amz-bucket-region']
+          super(context, message, data)
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/customizations/object.rb

@@ -27,10 +27,13 @@ module Aws
       #   necessary for objects larger than 5GB and can provide
       #   performance improvements on large objects. Amazon S3 does
       #   not accept multipart copies for objects smaller than 5MB.
+      #   Object metadata such as Content-Type will be copied, however,
+      #   Checksums are not copied.
       #
       # @option options [Integer] :content_length Only used when
       #   `:multipart_copy` is `true`. Passing this options avoids a HEAD
-      #   request to query the source object size. Raises an `ArgumentError` if
+      #   request to query the source object size but prevents object metadata
+      #   from being copied. Raises an `ArgumentError` if
       #   this option is provided when `:multipart_copy` is `false` or not set.
       #
       # @option options [S3::Client] :copy_source_client Only used when
@@ -161,7 +164,7 @@ module Aws
       #
       # @param [Symbol] method
       #   The S3 operation to generate a presigned URL for. Valid values
-      #   are `:get`, `:put`, `:head`, `:delete`, `:create_multipart_upload`, 
+      #   are `:get`, `:put`, `:head`, `:delete`, `:create_multipart_upload`,
       #   `:list_multipart_uploads`, `:complete_multipart_upload`,
       #   `:abort_multipart_upload`, `:list_parts`, and `:upload_part`.
       #
@@ -215,6 +218,79 @@ module Aws
         )
       end
 
+      # Allows you to create presigned URL requests for S3 operations. This
+      # method returns a tuple containing the URL and the signed X-amz-* headers
+      # to be used with the presigned url.
+      #
+      # @example Pre-signed GET URL, valid for one hour
+      #
+      #     obj.presigned_request(:get, expires_in: 3600)
+      #     #=> ["https://bucket-name.s3.amazonaws.com/object-key?...", {}]
+      #
+      # @example Pre-signed PUT with a canned ACL
+      #
+      #     # the object uploaded using this URL will be publicly accessible
+      #     obj.presigned_request(:put, acl: 'public-read')
+      #     #=> ["https://bucket-name.s3.amazonaws.com/object-key?...",
+      #      {"x-amz-acl"=>"public-read"}]
+      #
+      # @param [Symbol] method
+      #   The S3 operation to generate a presigned request for. Valid values
+      #   are `:get`, `:put`, `:head`, `:delete`, `:create_multipart_upload`,
+      #   `:list_multipart_uploads`, `:complete_multipart_upload`,
+      #   `:abort_multipart_upload`, `:list_parts`, and `:upload_part`.
+      #
+      # @param [Hash] params
+      #   Additional request parameters to use when generating the pre-signed
+      #   request. See the related documentation in {Client} for accepted
+      #   params.
+      #
+      #   | Method                       | Client Method                      |
+      #   |------------------------------|------------------------------------|
+      #   | `:get`                       | {Client#get_object}                |
+      #   | `:put`                       | {Client#put_object}                |
+      #   | `:head`                      | {Client#head_object}               |
+      #   | `:delete`                    | {Client#delete_object}             |
+      #   | `:create_multipart_upload`   | {Client#create_multipart_upload}   |
+      #   | `:list_multipart_uploads`    | {Client#list_multipart_uploads}    |
+      #   | `:complete_multipart_upload` | {Client#complete_multipart_upload} |
+      #   | `:abort_multipart_upload`    | {Client#abort_multipart_upload}    |
+      #   | `:list_parts`                | {Client#list_parts}                |
+      #   | `:upload_part`               | {Client#upload_part}               |
+      #
+      # @option params [Boolean] :virtual_host (false) When `true` the
+      #   presigned URL will use the bucket name as a virtual host.
+      #
+      #     bucket = Aws::S3::Bucket.new('my.bucket.com')
+      #     bucket.object('key').presigned_request(virtual_host: true)
+      #     #=> ["http://my.bucket.com/key?...", {}]
+      #
+      # @option params [Integer] :expires_in (900) Number of seconds before
+      #   the pre-signed URL expires. This may not exceed one week (604800
+      #   seconds). Note that the pre-signed URL is also only valid as long as
+      #   credentials used to sign it are. For example, when using IAM roles,
+      #   temporary tokens generated for signing also have a default expiration
+      #   which will affect the effective expiration of the pre-signed URL.
+      #
+      # @raise [ArgumentError] Raised if `:expires_in` exceeds one week
+      #   (604800 seconds).
+      #
+      # @return [String, Hash] A tuple with a presigned URL and headers that
+      #   should be included with the request.
+      #
+      def presigned_request(method, params = {})
+        presigner = Presigner.new(client: client)
+
+        if %w(delete head get put).include?(method.to_s)
+          method = "#{method}_object".to_sym
+        end
+
+        presigner.presigned_request(
+          method.downcase,
+          params.merge(bucket: bucket_name, key: key)
+        )
+      end
+
       # Returns the public (un-signed) URL for this object.
       #
       #     s3.bucket('bucket-name').object('obj-key').public_url
@@ -327,7 +403,7 @@ module Aws
       #     progress = Proc.new do |bytes, totals|
       #       puts bytes.map.with_index { |b, i| "Part #{i+1}: #{b} / #{totals[i]}"}.join(' ') + "Total: #{100.0 * bytes.sum / totals.sum }%" }
       #     end
-      #     obj.upload_file('/path/to/file')
+      #     obj.upload_file('/path/to/file', progress_callback: progress)
       #
       # @param [String, Pathname, File, Tempfile] source A file on the local
       #   file system that will be uploaded as this object. This can either be
@@ -391,7 +467,7 @@ module Aws
       #  customizing each range size in multipart_download,
       #  By default, `auto` mode is enabled, which performs multipart_download
       #
-      # @option options [String] chunk_size required in get_range mode.
+      # @option options [Integer] chunk_size required in get_range mode.
       #
       # @option options [Integer] thread_count (10) Customize threads used in
       #   the multipart download.

data/lib/aws-sdk-s3/customizations/types/permanent_redirect.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Aws
+  module S3
+    module Types
+      # This error is not modeled.
+      #
+      # The bucket you are attempting to access must be addressed using the
+      # specified endpoint. Please send all future requests to this endpoint.
+      #
+      # @!attribute [rw] endpoint
+      #   @return [String]
+      #
+      # @!attribute [rw] bucket
+      #   @return [String]
+      #
+      # @!attribute [rw] message
+      #   @return [String]
+      #
+      class PermanentRedirect < Struct.new(:endpoint, :bucket, :region, :message)
+        SENSITIVE = []
+        include Aws::Structure
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/customizations.rb

@@ -18,10 +18,12 @@ require 'aws-sdk-s3/presigner'
 
 # customizations to generated classes
 require 'aws-sdk-s3/customizations/bucket'
+require 'aws-sdk-s3/customizations/errors'
 require 'aws-sdk-s3/customizations/object'
 require 'aws-sdk-s3/customizations/object_summary'
 require 'aws-sdk-s3/customizations/multipart_upload'
 require 'aws-sdk-s3/customizations/types/list_object_versions_output'
+require 'aws-sdk-s3/customizations/types/permanent_redirect'
 
 [
   Aws::S3::Object::Collection,

data/lib/aws-sdk-s3/endpoint_parameters.rb

@@ -0,0 +1,142 @@
+# 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
+  # Endpoint parameters used to influence endpoints per request.
+  #
+  # @!attribute bucket
+  #   The S3 bucket used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 bucket.
+  #
+  #   @return [String]
+  #
+  # @!attribute region
+  #   The AWS region used to dispatch the request.
+  #
+  #   @return [String]
+  #
+  # @!attribute use_fips
+  #   When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
+  #
+  #   @return [Boolean]
+  #
+  # @!attribute use_dual_stack
+  #   When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
+  #
+  #   @return [Boolean]
+  #
+  # @!attribute endpoint
+  #   Override the endpoint used to send this request
+  #
+  #   @return [String]
+  #
+  # @!attribute force_path_style
+  #   When true, force a path-style endpoint to be used where the bucket name is part of the path.
+  #
+  #   @return [Boolean]
+  #
+  # @!attribute accelerate
+  #   When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
+  #
+  #   @return [Boolean]
+  #
+  # @!attribute use_global_endpoint
+  #   Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
+  #
+  #   @return [Boolean]
+  #
+  # @!attribute use_object_lambda_endpoint
+  #   Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
+  #
+  #   @return [Boolean]
+  #
+  # @!attribute disable_access_points
+  #   Internal parameter to disable Access Point Buckets
+  #
+  #   @return [Boolean]
+  #
+  # @!attribute disable_multi_region_access_points
+  #   Whether multi-region access points (MRAP) should be disabled.
+  #
+  #   @return [Boolean]
+  #
+  # @!attribute use_arn_region
+  #   When an Access Point ARN is provided and this flag is enabled, the SDK MUST use the ARN's region when constructing the endpoint instead of the client's configured region.
+  #
+  #   @return [Boolean]
+  #
+  EndpointParameters = Struct.new(
+    :bucket,
+    :region,
+    :use_fips,
+    :use_dual_stack,
+    :endpoint,
+    :force_path_style,
+    :accelerate,
+    :use_global_endpoint,
+    :use_object_lambda_endpoint,
+    :disable_access_points,
+    :disable_multi_region_access_points,
+    :use_arn_region,
+  ) do
+    include Aws::Structure
+
+    # @api private
+    class << self
+      PARAM_MAP = {
+        'Bucket' => :bucket,
+        'Region' => :region,
+        'UseFIPS' => :use_fips,
+        'UseDualStack' => :use_dual_stack,
+        'Endpoint' => :endpoint,
+        'ForcePathStyle' => :force_path_style,
+        'Accelerate' => :accelerate,
+        'UseGlobalEndpoint' => :use_global_endpoint,
+        'UseObjectLambdaEndpoint' => :use_object_lambda_endpoint,
+        'DisableAccessPoints' => :disable_access_points,
+        'DisableMultiRegionAccessPoints' => :disable_multi_region_access_points,
+        'UseArnRegion' => :use_arn_region,
+      }.freeze
+    end
+
+    def initialize(options = {})
+      self[:bucket] = options[:bucket]
+      self[:region] = options[:region]
+      self[:use_fips] = options[:use_fips]
+      self[:use_fips] = false if self[:use_fips].nil?
+      if self[:use_fips].nil?
+        raise ArgumentError, "Missing required EndpointParameter: :use_fips"
+      end
+      self[:use_dual_stack] = options[:use_dual_stack]
+      self[:use_dual_stack] = false if self[:use_dual_stack].nil?
+      if self[:use_dual_stack].nil?
+        raise ArgumentError, "Missing required EndpointParameter: :use_dual_stack"
+      end
+      self[:endpoint] = options[:endpoint]
+      self[:force_path_style] = options[:force_path_style]
+      self[:accelerate] = options[:accelerate]
+      self[:accelerate] = false if self[:accelerate].nil?
+      if self[:accelerate].nil?
+        raise ArgumentError, "Missing required EndpointParameter: :accelerate"
+      end
+      self[:use_global_endpoint] = options[:use_global_endpoint]
+      self[:use_global_endpoint] = false if self[:use_global_endpoint].nil?
+      if self[:use_global_endpoint].nil?
+        raise ArgumentError, "Missing required EndpointParameter: :use_global_endpoint"
+      end
+      self[:use_object_lambda_endpoint] = options[:use_object_lambda_endpoint]
+      self[:disable_access_points] = options[:disable_access_points]
+      self[:disable_multi_region_access_points] = options[:disable_multi_region_access_points]
+      self[:disable_multi_region_access_points] = false if self[:disable_multi_region_access_points].nil?
+      if self[:disable_multi_region_access_points].nil?
+        raise ArgumentError, "Missing required EndpointParameter: :disable_multi_region_access_points"
+      end
+      self[:use_arn_region] = options[:use_arn_region]
+    end
+  end
+end