aws-sdk-resources 2.3.23 → 3.69.0

data/lib/aws-sdk-resources/services/s3/multipart_upload.rb

@@ -1,42 +0,0 @@
-module Aws
-  module S3
-    class MultipartUpload
-
-      alias_method :basic_complete, :complete
-
-      # Completes the upload, requires a list of completed parts. You can
-      # provide the list of parts with `:part_number` and `:etag` values.
-      #
-      #     upload.complete(multipart_upload: { parts: [
-      #       { part_number: 1, etag:'etag1' },
-      #       { part_number: 2, etag:'etag2' },
-      #       ...
-      #     ]})
-      #
-      # Alternatively, you can pass **`compute_parts: true`** and the part
-      # list will be computed by calling {Client#list_parts}.
-      #
-      #     upload.complete(compute_parts: true)
-      #
-      # @option options [Boolean] :compute_parts (false) When `true`,
-      #   the {Client#list_parts} method will be called to determine
-      #   the list of required part numbers and their ETags.
-      #
-      def complete(options = {})
-        if options.delete(:compute_parts)
-          options[:multipart_upload] = { parts: compute_parts }
-        end
-        basic_complete(options)
-      end
-
-      private
-
-      def compute_parts
-        parts.sort_by(&:part_number).each.with_object([]) do |part, part_list|
-          part_list << { part_number: part.part_number, etag: part.etag }
-        end
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-resources/services/s3/multipart_upload_error.rb

@@ -1,16 +0,0 @@
-module Aws
-  module S3
-    class MultipartUploadError < StandardError
-
-      def initialize(message, errors)
-        @errors = errors
-        super(message)
-      end
-
-      # @return [Array<StandardError>] The list of errors encountered
-      #   when uploading or aborting the upload.
-      attr_reader :errors
-
-    end
-  end
-end

data/lib/aws-sdk-resources/services/s3/object.rb

@@ -1,257 +0,0 @@
-module Aws
-  module S3
-    class Object
-
-      alias size content_length
-
-      # Copies another object to this object. Use `multipart_copy: true`
-      # for large objects. This is required for objects that exceed 5GB.
-      #
-      # @param [S3::Object, S3::ObjectVersion, S3::ObjectSummary, String, Hash] source
-      #   Where to copy object data from. `source` must be one of the following:
-      #
-      #   * {Aws::S3::Object}
-      #   * {Aws::S3::ObjectSummary}
-      #   * {Aws::S3::ObjectVersion}
-      #   * Hash - with `:bucket` and `:key` and optional `:version_id`
-      #   * String - formatted like `"source-bucket-name/uri-escaped-key"`
-      #     or `"source-bucket-name/uri-escaped-key?versionId=version-id"`
-      #
-      # @option options [Boolean] :multipart_copy (false) When `true`,
-      #   the object will be copied using the multipart APIs. This is
-      #   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.
-      #
-      # @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.
-      #
-      # @option options [S3::Client] :copy_source_client Only used when
-      #   `:multipart_copy` is `true` and the source object is in a
-      #   different region. You do not need to specify this option
-      #   if you have provided `:content_length`.
-      #
-      # @option options [String] :copy_source_region Only used when
-      #   `:multipart_copy` is `true` and the source object is in a
-      #   different region. You do not need to specify this option
-      #   if you have provided a `:source_client` or a `:content_length`.
-      #
-      # @example Basic object copy
-      #
-      #   bucket = Aws::S3::Bucket.new('target-bucket')
-      #   object = bucket.object('target-key')
-      #
-      #   # source as String
-      #   object.copy_from('source-bucket/source-key')
-      #
-      #   # source as Hash
-      #   object.copy_from(bucket:'source-bucket', key:'source-key')
-      #
-      #   # source as Aws::S3::Object
-      #   object.copy_from(bucket.object('source-key'))
-      #
-      # @example Managed copy of large objects
-      #
-      #   # uses multipart upload APIs to copy object
-      #   object.copy_from('src-bucket/src-key', multipart_copy: true)
-      #
-      # @see #copy_to
-      #
-      def copy_from(source, options = {})
-        if Hash === source && source[:copy_source]
-          # for backwards compatibility
-          @client.copy_object(source.merge(bucket: bucket_name, key: key))
-        else
-          ObjectCopier.new(self, options).copy_from(source, options)
-        end
-      end
-
-      # Copies this object to another object. Use `multipart_copy: true`
-      # for large objects. This is required for objects that exceed 5GB.
-      #
-      # @note If you need to copy to a bucket in a different region, use
-      #   {#copy_from}.
-      #
-      # @param [S3::Object, String, Hash] target Where to copy the object
-      #   data to. `target` must be one of the following:
-      #
-      #   * {Aws::S3::Object}
-      #   * Hash - with `:bucket` and `:key`
-      #   * String - formatted like `"target-bucket-name/target-key"`
-      #
-      # @example Basic object copy
-      #
-      #   bucket = Aws::S3::Bucket.new('source-bucket')
-      #   object = bucket.object('source-key')
-      #
-      #   # target as String
-      #   object.copy_to('target-bucket/target-key')
-      #
-      #   # target as Hash
-      #   object.copy_to(bucket: 'target-bucket', key: 'target-key')
-      #
-      #   # target as Aws::S3::Object
-      #   object.copy_to(bucket.object('target-key'))
-      #
-      # @example Managed copy of large objects
-      #
-      #   # uses multipart upload APIs to copy object
-      #   object.copy_to('src-bucket/src-key', multipart_copy: true)
-      #
-      def copy_to(target, options = {})
-        ObjectCopier.new(self, options).copy_to(target, options)
-      end
-
-      # Copies and deletes the current object. The object will only be
-      # deleted if the copy operation succeeds.
-      # @param (see Object#copy_to)
-      # @option (see Object#copy_to)
-      # @return [void]
-      # @see Object#copy_to
-      # @see Object#delete
-      def move_to(target, options = {})
-        copy_to(target, options)
-        delete
-      end
-
-      # Creates a {PresignedPost} that makes it easy to upload a file from
-      # a web browser direct to Amazon S3 using an HTML post form with
-      # a file field.
-      #
-      # See the {PresignedPost} documentation for more information.
-      #
-      # @option (see PresignedPost#initialize)
-      # @return [PresignedPost]
-      # @see PresignedPost
-      def presigned_post(options = {})
-        PresignedPost.new(
-          client.config.credentials,
-          client.config.region,
-          bucket_name,
-          {
-            key: key,
-            url: bucket.url,
-          }.merge(options)
-        )
-      end
-
-      # Generates a pre-signed URL for this object.
-      #
-      # @example Pre-signed GET URL, valid for one hour
-      #
-      #     obj.presigned_url(: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_url(:put, acl: 'public-read')
-      #     #=> "https://bucket-name.s3.amazonaws.com/object-key?..."
-      #
-      # @param [Symbol] http_method
-      #   The HTTP method to generate a presigned URL for. Valid values
-      #   are `:get`, `:put`, `:head`, and `:delete`.
-      #
-      # @param [Hash] params
-      #   Additional request parameters to use when generating the pre-signed
-      #   URL. See the related documentation in {Client} for accepted
-      #   params.
-      #
-      #   | HTTP Method   | Client Method          |
-      #   |---------------|------------------------|
-      #   | `:get`        | {Client#get_object}    |
-      #   | `:put`        | {Client#put_object}    |
-      #   | `:head`       | {Client#head_object}   |
-      #   | `:delete`     | {Client#delete_object} |
-      #
-      # @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_url(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]
-      #
-      def presigned_url(http_method, params = {})
-        presigner = Presigner.new(client: client)
-        presigner.presigned_url("#{http_method.downcase}_object", 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
-      #     #=> "https://bucket-name.s3.amazonaws.com/obj-key"
-      #
-      # To use virtual hosted bucket url (disables https):
-      #
-      #     s3.bucket('my.bucket.com').object('key').public_url(virtual_host: true)
-      #     #=> "http://my.bucket.com/key"
-      #
-      # @option options [Boolean] :virtual_host (false) When `true`, the bucket
-      #   name will be used as the host name. This is useful when you have
-      #   a CNAME configured for the bucket.
-      #
-      # @return [String]
-      def public_url(options = {})
-        url = URI.parse(bucket.url(options))
-        url.path += '/' unless url.path[-1] == '/'
-        url.path += key.gsub(/[^\/]+/) { |s| Seahorse::Util.uri_escape(s) }
-        url.to_s
-      end
-
-      # Uploads a file from disk to the current object in S3.
-      #
-      #     # small files are uploaded in a single API call
-      #     obj.upload_file('/path/to/file')
-      #
-      # Files larger than `:multipart_threshold` are uploaded using the
-      # Amazon S3 multipart upload APIs.
-      #
-      #     # large files are automatically split into parts
-      #     # and the parts are uploaded in parallel
-      #     obj.upload_file('/path/to/very_large_file')
-      #
-      # @param [String,Pathname,File,Tempfile] source A file or path to a file
-      #   on the local file system that should be uploaded to this object.
-      #   If you pass an open file object, then it is your responsibility
-      #   to close the file object once the upload completes.
-      #
-      # @option options [Integer] :multipart_threshold (15728640) Files larger
-      #   than `:multipart_threshold` are uploaded using the S3 multipart APIs.
-      #   Default threshold is 15MB.
-      #
-      # @raise [MultipartUploadError] If an object is being uploaded in
-      #   parts, and the upload can not be completed, then the upload is
-      #   aborted and this error is raised.  The raised error has a `#errors`
-      #   method that returns the failures that caused the upload to be
-      #   aborted.
-      #
-      # @return [Boolean] Returns `true` when the object is uploaded
-      #   without any errors.
-      #
-      def upload_file(source, options = {})
-        uploader = FileUploader.new(
-          multipart_threshold: options.delete(:multipart_threshold),
-          client: client)
-        uploader.upload(source, options.merge(bucket: bucket_name, key: key))
-        true
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-resources/services/s3/object_copier.rb

@@ -1,99 +0,0 @@
-require 'thread'
-
-module Aws
-  module S3
-    # @api private
-    class ObjectCopier
-
-      # @param [S3::Object] object
-      def initialize(object, options = {})
-        @object = object
-        @options = options.merge(client: @object.client)
-      end
-
-      def copy_from(source, options = {})
-        copy_object(source, @object, merge_options(source, options))
-      end
-
-      def copy_to(target, options = {})
-        copy_object(@object, target, merge_options(target, options))
-      end
-
-      private
-
-      def copy_object(source, target, options)
-        target_bucket, target_key = copy_target(target)
-        options[:bucket] = target_bucket
-        options[:key] = target_key
-        options[:copy_source] = copy_source(source)
-        if options.delete(:multipart_copy)
-          apply_source_client(source, options)
-          ObjectMultipartCopier.new(@options).copy(options)
-        else
-          @object.client.copy_object(options)
-        end
-      end
-
-      def copy_source(source)
-        case source
-        when String then source
-        when Hash
-          src = "#{source[:bucket]}/#{escape(source[:key])}"
-          src += "?versionId=#{source[:version_id]}" if source.key?(:version_id)
-          src
-        when S3::Object, S3::ObjectSummary
-          "#{source.bucket_name}/#{escape(source.key)}"
-        when S3::ObjectVersion
-          "#{source.bucket_name}/#{escape(source.object_key)}?versionId=#{source.id}"
-        else
-          msg = "expected source to be an Aws::S3::Object, Hash, or String"
-          raise ArgumentError, msg
-        end
-      end
-
-      def copy_target(target)
-        case target
-        when String then target.match(/([^\/]+?)\/(.+)/)[1,2]
-        when Hash then target.values_at(:bucket, :key)
-        when S3::Object then [target.bucket_name, target.key]
-        else
-          msg = "expected target to be an Aws::S3::Object, Hash, or String"
-          raise ArgumentError, msg
-        end
-      end
-
-      def merge_options(source_or_target, options)
-        if Hash === source_or_target
-          source_or_target.inject(options.dup) do |opts, (key, value)|
-            opts[key] = value unless [:bucket, :key, :version_id].include?(key)
-            opts
-          end
-        else
-          options.dup
-        end
-      end
-
-      def apply_source_client(source, options)
-
-        if source.respond_to?(:client)
-          options[:copy_source_client] ||= source.client
-        end
-
-        if options[:copy_source_region]
-          config = @object.client.config
-          config = config.each_pair.inject({}) { |h, (k,v)| h[k] = v; h }
-          config[:region] = options.delete(:copy_source_region)
-          options[:copy_source_client] ||= S3::Client.new(config)
-        end
-
-        options[:copy_source_client] ||= @object.client
-
-      end
-
-      def escape(str)
-        Seahorse::Util.uri_path_escape(str)
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-resources/services/s3/object_multipart_copier.rb

@@ -1,179 +0,0 @@
-require 'thread'
-
-module Aws
-  module S3
-    # @api private
-    class ObjectMultipartCopier
-
-      FIVE_MB = 5 * 1024 * 1024 # 5MB
-
-      FILE_TOO_SMALL = "unable to multipart copy files smaller than 5MB"
-
-      MAX_PARTS = 10_000
-
-      # @option options [Client] :client
-      # @option [Integer] :min_part_size (52428800) Size of copied parts.
-      #   Defaults to 50MB.
-      #   will be constructed from the given `options' hash.
-      # @option [Integer] :thread_count (10) Number of concurrent threads to
-      #   use for copying parts.
-      def initialize(options = {})
-        @thread_count = options.delete(:thread_count) || 10
-        @min_part_size = options.delete(:min_part_size) || (FIVE_MB * 10)
-        @client = options[:client] || Client.new
-      end
-
-      # @return [Client]
-      attr_reader :client
-
-      # @option (see S3::Client#copy_object)
-      def copy(options = {})
-        size = source_size(options)
-        options[:upload_id] = initiate_upload(options)
-        begin
-          parts = copy_parts(size, default_part_size(size), options)
-          complete_upload(parts, options)
-        rescue => error
-          abort_upload(options)
-          raise error
-        end
-      end
-
-      private
-
-      def initiate_upload(options)
-        options = options_for(:create_multipart_upload, options)
-        @client.create_multipart_upload(options).upload_id
-      end
-
-      def copy_parts(size, default_part_size, options)
-        queue = PartQueue.new(compute_parts(size, default_part_size, options))
-        threads = []
-        @thread_count.times do
-          threads << copy_part_thread(queue)
-        end
-        threads.map(&:value).flatten.sort_by{ |part| part[:part_number] }
-      end
-
-      def copy_part_thread(queue)
-        Thread.new do
-          begin
-            completed = []
-            while part = queue.shift
-              completed << copy_part(part)
-            end
-            completed
-          rescue => error
-            queue.clear!
-            raise error
-          end
-        end
-      end
-
-      def copy_part(part)
-        {
-          etag: @client.upload_part_copy(part).copy_part_result.etag,
-          part_number: part[:part_number],
-        }
-      end
-
-      def complete_upload(parts, options)
-        options = options_for(:complete_multipart_upload, options)
-        options[:multipart_upload] = { parts: parts }
-        @client.complete_multipart_upload(options)
-      end
-
-      def abort_upload(options)
-        @client.abort_multipart_upload({
-          bucket: options[:bucket],
-          key: options[:key],
-          upload_id: options[:upload_id],
-        })
-      end
-
-      def compute_parts(size, default_part_size, options)
-        part_number = 1
-        offset = 0
-        parts = []
-        options = options_for(:upload_part_copy, options)
-        while offset < size
-          parts << options.merge({
-            part_number: part_number,
-            copy_source_range: byte_range(offset, default_part_size, size),
-          })
-          part_number += 1
-          offset += default_part_size
-        end
-        parts
-      end
-
-      def byte_range(offset, default_part_size, size)
-        if offset + default_part_size < size
-          "bytes=#{offset}-#{offset + default_part_size - 1}"
-        else
-          "bytes=#{offset}-#{size - 1}"
-        end
-      end
-
-      def source_size(options)
-        return options.delete(:content_length) if options[:content_length]
-
-        client = options[:copy_source_client] || @client
-
-        if vid_match = options[:copy_source].match(/([^\/]+?)\/(.+)\?versionId=(.+)/)
-          bucket, key, version_id = vid_match[1,3]
-        else
-          bucket, key = options[:copy_source].match(/([^\/]+?)\/(.+)/)[1,2]
-        end
-        
-        key = CGI.unescape(key)
-        opts = { bucket: bucket, key: key }
-        opts[:version_id] = version_id if version_id
-        client.head_object(opts).content_length
-      end
-
-      def default_part_size(source_size)
-        if source_size < FIVE_MB
-          raise ArgumentError, FILE_TOO_SMALL
-        else
-          [(source_size.to_f / MAX_PARTS).ceil, @min_part_size].max.to_i
-        end
-      end
-
-      def options_for(operation_name, options)
-        API_OPTIONS[operation_name].inject({}) do |hash, opt_name|
-          hash[opt_name] = options[opt_name] if options.key?(opt_name)
-          hash
-        end
-      end
-
-      # @api private
-      def self.options_for(shape_name)
-        Client.api.metadata['shapes'][shape_name].member_names
-      end
-
-      API_OPTIONS = {
-        create_multipart_upload: options_for('CreateMultipartUploadRequest'),
-        upload_part_copy: options_for('UploadPartCopyRequest'),
-        complete_multipart_upload: options_for('CompleteMultipartUploadRequest'),
-      }
-
-      class PartQueue
-
-        def initialize(parts = [])
-          @parts = parts
-          @mutex = Mutex.new
-        end
-
-        def shift
-          @mutex.synchronize { @parts.shift }
-        end
-
-        def clear!
-          @mutex.synchronize { @parts.clear }
-        end
-
-      end
-    end
-  end
-end