aws-sdk 1.9.5 → 1.10.0

data/lib/aws/route_53/client.rb

@@ -142,6 +142,7 @@ module AWS
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
+      #
       #   * `:change_info` - (Hash)
       #     * `:id` - (String)
       #     * `:status` - (String)
@@ -180,6 +181,7 @@ module AWS
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
+      #
       #   * `:health_check` - (Hash)
       #     * `:id` - (String)
       #     * `:caller_reference` - (String)
@@ -219,6 +221,7 @@ module AWS
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
+      #
       #   * `:hosted_zone` - (Hash)
       #     * `:id` - (String)
       #     * `:name` - (String)
@@ -250,6 +253,7 @@ module AWS
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
+      #
       #   * `:change_info` - (Hash)
       #     * `:id` - (String)
       #     * `:status` - (String)
@@ -266,6 +270,7 @@ module AWS
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
+      #
       #   * `:change_info` - (Hash)
       #     * `:id` - (String)
       #     * `:status` - (String)
@@ -280,6 +285,7 @@ module AWS
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
+      #
       #   * `:health_check` - (Hash)
       #     * `:id` - (String)
       #     * `:caller_reference` - (String)
@@ -298,6 +304,7 @@ module AWS
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
+      #
       #   * `:hosted_zone` - (Hash)
       #     * `:id` - (String)
       #     * `:name` - (String)
@@ -320,6 +327,7 @@ module AWS
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
+      #
       #   * `:health_checks` - (Array<Hash>)
       #     * `:id` - (String)
       #     * `:caller_reference` - (String)
@@ -346,6 +354,7 @@ module AWS
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
+      #
       #   * `:hosted_zones` - (Array<Hash>)
       #     * `:id` - (String)
       #     * `:name` - (String)
@@ -393,6 +402,7 @@ module AWS
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
+      #
       #   * `:resource_record_sets` - (Array<Hash>)
       #     * `:name` - (String)
       #     * `:type` - (String)

data/lib/aws/s3.rb

@@ -81,7 +81,7 @@ module AWS
   #     obj.write(Pathname.new('/path/to/file.txt'))
   #
   #     # streaming download from S3 to a file on disk
-  #     File.open('file.txt', 'w') do |file|
+  #     File.open('file.txt', 'wb') do |file|
   #       obj.read do |chunk|
   #          file.write(chunk)
   #       end

data/lib/aws/s3/client.rb

@@ -771,33 +771,6 @@ module AWS
       #     :data => 'This is the readme for ...',
       #   })
       #
-      # ## Block Form
-      #
-      # In block form, this method yields a stream to the block that
-      # accepts data chunks.  For example:
-      #
-      #   s3_client.put_object(
-      #     :bucket_name => 'mybucket',
-      #     :key => 'some/key'
-      #     :content_length => File.size('myfile')
-      #   ) do |buffer|
-      #
-      #     File.open('myfile') do |io|
-      #       buffer.write(io.read(length)) until io.eof?
-      #     end
-      #
-      #   end
-      #
-      # This form is useful if you need finer control over how
-      # potentially large amounts of data are read from another
-      # source before being sent to S3; for example, if you are
-      # using a non-blocking IO model and reading from a large file
-      # on disk or from another network stream.  Some HTTP handlers
-      # do not support streaming request bodies, so if you plan to
-      # upload large objects using this interface you should make
-      # sure the HTTP handler you configure for the client meets
-      # your needs.
-      #
       # @overload put_object(options = {})
       #   @param [Hash] options
       #   @option options [required,String] :bucket_name
@@ -1364,6 +1337,39 @@ module AWS
 
       end
 
+      object_method(:copy_part, :put, XML::CopyPart, :header_options => {
+        :copy_source => 'x-amz-copy-source',
+        :copy_source_range => 'x-amz-copy-source-range',
+      }) do
+
+        configure_request do |request, options|
+
+          validate!(:copy_source, options[:copy_source]) do
+            "may not be blank" if options[:copy_source].to_s.empty?
+          end
+
+          validate!(:copy_source_range, options[:copy_source_range]) do
+            "must start with bytes=" if options[:copy_source_range] && !options[:copy_source_range].start_with?("bytes=")
+          end
+
+          options = options.merge(:copy_source => escape_path(options[:copy_source]))
+
+          require_upload_id!(options[:upload_id])
+          request.add_param('uploadId', options[:upload_id])
+
+          require_part_number!(options[:part_number])
+          request.add_param('partNumber', options[:part_number])
+
+          super(request, options)
+
+          if options[:version_id]
+            req.headers['x-amz-copy-source'] += "?versionId=#{options[:version_id]}"
+          end
+
+        end
+
+      end
+
       protected
 
       def extract_error_details response
@@ -1434,6 +1440,15 @@ module AWS
         Base64.encode64(Digest::MD5.digest(str)).strip
       end
 
+      def parse_copy_part_response resp
+        doc = REXML::Document.new(resp.http_response.body)
+        resp[:etag] = doc.root.elements["ETag"].text
+        resp[:last_modified] = doc.root.elements["LastModified"].text
+        if header = resp.http_response.headers['x-amzn-requestid']
+          data[:request_id] = [header].flatten.first
+        end
+      end
+
       def extract_object_headers resp
         meta = {}
         resp.http_response.headers.each_pair do |name,value|

data/lib/aws/s3/client/xml.rb

@@ -225,6 +225,16 @@ module AWS
           end
         end
 
+        CopyPart = BaseGrammar.customize do
+          element "ETag" do
+            rename :etag
+          end
+          element "LastModified" do
+            datetime_value
+            rename :last_modified
+          end
+        end
+
       end
     end
   end

data/lib/aws/s3/multipart_upload.rb

@@ -204,6 +204,36 @@ module AWS
         UploadedPart.new(self, part_number)
       end
 
+      # Copies a part.
+      #
+      #   @param [string] copy_source Full S3 name of source, ie bucket/key
+      #
+      #   @param [Hash] options Additional options for the copy.
+      #
+      #   @option options [Integer] :part_number The part number.
+      #
+      #   @option options [Integer] :copy_source_range Range of bytes to copy, ie bytes=0-45687
+      def copy_part(copy_source, options = {})
+        part_options = base_opts.merge(options)
+        part_options.merge!(:copy_source => copy_source)
+
+        unless part_options[:part_number]
+          @increment_mutex.synchronize do
+            part_options[:part_number] = (@last_part += 1)
+          end
+        end
+        part_number = part_options[:part_number]
+
+        resp = client.copy_part(part_options)
+        @completed_mutex.synchronize do
+          @completed_parts[part_number] = {
+            :part_number => part_number,
+            :etag => resp[:etag]
+          }
+        end
+        UploadedPart.new(self, part_number)
+      end
+
       # Completes the upload by assembling previously uploaded
       # parts.
       #
@@ -282,26 +312,23 @@ module AWS
         "<#{self.class}:#{object.bucket.name}/#{object.key}:#{id}>"
       end
 
-      # @api private
       private
+
       def get_complete_opts(part_numbers = nil)
-        parts_resp = client.list_parts(base_opts)
-        complete_opts =
-          base_opts.merge(:parts =>
-                          parts_resp.parts.map do |part|
-                            { :part_number => part.part_number,
-                              :etag => part.etag }
-                          end)
-
-        complete_opts[:parts].reject! do |part|
-          !part_numbers.include?(part[:part_number])
-        end if part_numbers
-
-        complete_opts
+        parts = []
+        self.parts.each do |part|
+          parts << { :part_number => part.part_number, :etag => part.etag }
+        end
+
+        if part_numbers
+          parts.reject! do |part|
+            !part_numbers.include?(part[:part_number])
+          end
+        end
+
+        base_opts.merge(:parts => parts)
       end
 
-      # @api private
-      private
       def base_opts
         opts = {
           :bucket_name => object.bucket.name,

data/lib/aws/s3/s3_object.rb

@@ -63,7 +63,7 @@ module AWS
     #     obj.write(:file => path_to_file)
     #
     #     # Also accepts an open file object
-    #     file = File.open(path_to_file, 'r')
+    #     file = File.open(path_to_file, 'rb')
     #     obj.write(file)
     #
     # All three examples above produce the same result.  The file
@@ -72,8 +72,8 @@ module AWS
     #
     # ## Streaming Uploads
     #
-    # When you call {#write} with any IO-like object (must respond to
-    # #read and #eof?), it will be streamed to S3 in chunks.
+    # When you call {#write} with an IO-like object, it will be streamed 
+    # to S3 in chunks.
     #
     # While it is possible to determine the size of many IO objects, you may
     # have to specify the :content_length of your IO object.
@@ -104,7 +104,7 @@ module AWS
     # If you want to stream an object from S3, you can pass a block
     # to {#read}.
     #
-    #     File.open('output', 'w') do |file|
+    #     File.open('output', 'wb') do |file|
     #       large_object.read do |chunk|
     #         file.write(chunk)
     #       end
@@ -460,7 +460,7 @@ module AWS
       #     obj.write(Pathname.new('path/to/file.txt'))
       #
       #     # file objects
-      #     obj.write(File.open('path/to/file.txt', 'r'))
+      #     obj.write(File.open('path/to/file.txt', 'rb'))
       #
       #     # IO objects (must respond to #read and #eof?)
       #     obj.write(io)
@@ -838,6 +838,9 @@ module AWS
       #   when the object being copied was client-side encrypted.  This
       #   is important so the encryption metadata will be copied.
       #
+      # @option options [Boolean] :use_multipart_copy (false) Set this to
+      #   `true` if you need to copy an object that is larger than 5GB.
+      #
       # @option options :cache_control [String] Can be used to specify
       #   caching behavior.  See
       #   http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9
@@ -889,7 +892,11 @@ module AWS
         options[:bucket_name] = bucket.name
         options[:key] = key
 
-        client.copy_object(options)
+        if use_multipart_copy?(options)
+          multipart_copy(options)
+        else
+          resp = client.copy_object(options)
+        end
 
         nil
 
@@ -990,7 +997,7 @@ module AWS
       # the HTTP response.
       #
       #     # read an object from S3 to a file
-      #     File.open('output.txt', 'w') do |file|
+      #     File.open('output.txt', 'wb') do |file|
       #       bucket.objects['key'].read do |chunk|
       #         file.write(chunk)
       #       end
@@ -1173,6 +1180,8 @@ module AWS
       # @option options [Boolean] :secure (true) Whether to generate a
       #   secure (HTTPS) URL or a plain HTTP url.
       #
+      # @option options [String] :content_type
+      # @option options [String] :content_md5
       # @option options [String] :endpoint Sets the hostname of the
       #   endpoint.
       #
@@ -1208,23 +1217,23 @@ module AWS
       #   HTTP GET on the returned URL.
       # @return [URI::HTTP, URI::HTTPS]
       def url_for(method, options = {})
-
+        options = options.dup
         options[:secure] = config.use_ssl? unless options.key?(:secure)
+        options[:expires] = expiration_timestamp(options[:expires])
 
         req = request_for_signing(options)
-
-        method = http_method(method)
-        expires = expiration_timestamp(options[:expires])
-        req.add_param("AWSAccessKeyId",
-                      config.credential_provider.access_key_id)
+        req.http_method = http_method(method)
+        req.add_param("AWSAccessKeyId", config.credential_provider.access_key_id)
         req.add_param("versionId", options[:version_id]) if options[:version_id]
-        req.add_param("Signature", signature(method, expires, req))
-        req.add_param("Expires", expires)
-        req.add_param("x-amz-security-token",
-                      config.credential_provider.session_token) if
-          config.credential_provider.session_token
+        req.add_param("Signature", signature(req, options))
+        req.add_param("Expires", options[:expires])
+        if config.credential_provider.session_token
+          req.add_param(
+            "x-amz-security-token",
+            config.credential_provider.session_token
+          )
+        end
 
-        secure = options.fetch(:secure, config.use_ssl?)
         build_uri(req, options)
       end
 
@@ -1272,6 +1281,34 @@ module AWS
 
       private
 
+      # Used to determine if the data needs to be copied in parts
+      def use_multipart_copy? options
+        options[:use_multipart_copy]
+      end
+
+      def multipart_copy options
+
+        unless options[:content_length]
+          msg = "unknown content length, must set :content_length " +
+              "to use multi-part copy"
+          raise ArgumentError, msg
+        end
+
+        part_size = compute_part_size(options)
+        clean_up_options(options)
+        source_length = options.delete(:content_length)
+
+        multipart_upload(options) do |upload|
+          pos = 0
+          # We copy in part_size chunks until we read the 
+          until pos >= source_length
+            last_byte = (pos + part_size >= source_length) ? source_length - 1 : pos + part_size - 1
+            upload.copy_part(options[:copy_source], options.merge({:copy_source_range => "bytes=#{pos}-#{last_byte}"})) 
+            pos += part_size
+          end
+        end
+      end
+
       # @return [Boolean]
       def should_decrypt? options
         options[:encryption_key] or config.s3_encryption_key
@@ -1347,13 +1384,12 @@ module AWS
                         :query => request.querystring)
       end
 
-      def signature(method, expires, request)
-
+      def signature request, options
         parts = []
-        parts << method
-        parts << ""
-        parts << ""
-        parts << expires
+        parts << request.http_method
+        parts << options[:content_md5].to_s
+        parts << options[:content_type].to_s
+        parts << options[:expires]
         if token = config.credential_provider.session_token
           parts << "x-amz-security-token:#{token}"
         end
@@ -1363,7 +1399,6 @@ module AWS
 
         secret = config.credential_provider.secret_access_key
         Core::Signer.sign(secret, string_to_sign, 'sha1')
-
       end
 
       def expiration_timestamp(input)

data/lib/aws/s3/uploaded_part.rb

@@ -33,6 +33,7 @@ module AWS
       def initialize(upload, part_number, opts = {})
         @upload = upload
         @part_number = part_number
+        @etag = opts[:etag]
         super
       end
 
@@ -57,7 +58,8 @@ module AWS
 
       # @return [String] The ETag of the part.
       def etag
-        get_attribute(:etag)
+        @etag ||= get_attribute(:etag)
+        @etag
       end
 
       # @api private