fog-aws 0.0.5

data/lib/fog/aws/requests/storage/complete_multipart_upload.rb

@@ -0,0 +1,73 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+        require 'fog/aws/parsers/storage/complete_multipart_upload'
+
+        # Complete a multipart upload
+        #
+        # @param [String] bucket_name Name of bucket to complete multipart upload for
+        # @param [String] object_name Name of object to complete multipart upload for
+        # @param [String] upload_id Id of upload to add part to
+        # @param [Array<String>] parts Array of etags as Strings for parts
+        #
+        # @return [Excon::Response]
+        #   * body [Hash]: (success)
+        #     * Bucket [String] - bucket of new object
+        #     * ETag [String] - etag of new object
+        #     * Key [String] - key of new object
+        #     * Location [String] - location of new object
+        #   * body [Hash]: (failure)
+        #     * Code [String] - Error status code
+        #     * Message [String] - Error description
+        #
+        # @note This request could fail and still return +200 OK+, so it's important that you check the response.
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadComplete.html
+        #
+        def complete_multipart_upload(bucket_name, object_name, upload_id, parts)
+          data = "<CompleteMultipartUpload>"
+          parts.each_with_index do |part, index|
+            data << "<Part>"
+            data << "<PartNumber>#{index + 1}</PartNumber>"
+            data << "<ETag>#{part}</ETag>"
+            data << "</Part>"
+          end
+          data << "</CompleteMultipartUpload>"
+          request({
+            :body       => data,
+            :expects    => 200,
+            :headers    => { 'Content-Length' => data.length },
+            :bucket_name => bucket_name,
+            :object_name => object_name,
+            :method     => 'POST',
+            :parser     => Fog::Parsers::Storage::AWS::CompleteMultipartUpload.new,
+            :query      => {'uploadId' => upload_id}
+          })
+        end
+      end # Real
+
+      class Mock # :nodoc:all
+        require 'fog/aws/requests/storage/shared_mock_methods'
+        include Fog::Storage::AWS::SharedMockMethods
+
+        def complete_multipart_upload(bucket_name, object_name, upload_id, parts)
+          bucket = verify_mock_bucket_exists(bucket_name)
+          upload_info = get_upload_info(bucket_name, upload_id, true)
+          body = parts.map { |pid| upload_info[:parts][pid.to_i] }.join
+          object = store_mock_object(bucket, object_name, body, upload_info[:options])
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            'Location' => "http://#{bucket_name}.s3.amazonaws.com/#{object_name}",
+            'Bucket'   => bucket_name,
+            'Key'      => object_name,
+            'ETag'     => object['ETag'],
+          }
+          response.headers['x-amz-version-id'] = object['VersionId'] if object['VersionId'] != 'null'
+          response
+        end
+      end # Mock
+    end # Storage
+  end # AWS
+end # Fog

data/lib/fog/aws/requests/storage/copy_object.rb

@@ -0,0 +1,77 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+        require 'fog/aws/parsers/storage/copy_object'
+
+        # Copy an object from one S3 bucket to another
+        #
+        # @param source_bucket_name [String] Name of source bucket
+        # @param source_object_name [String] Name of source object
+        # @param target_bucket_name [String] Name of bucket to create copy in
+        # @param target_object_name [String] Name for new copy of object
+        #
+        # @param options [Hash]:
+        # @option options [String] x-amz-metadata-directive Specifies whether to copy metadata from source or replace with data in request.  Must be in ['COPY', 'REPLACE']
+        # @option options [String] x-amz-copy_source-if-match Copies object if its etag matches this value
+        # @option options [Time] x-amz-copy_source-if-modified_since Copies object it it has been modified since this time
+        # @option options [String] x-amz-copy_source-if-none-match Copies object if its etag does not match this value
+        # @option options [Time] x-amz-copy_source-if-unmodified-since Copies object it it has not been modified since this time
+        # @option options [String] x-amz-storage-class Default is 'STANDARD', set to 'REDUCED_REDUNDANCY' for non-critical, reproducable data
+        #
+        #
+        # @return [Excon::Response]
+        #   * body [Hash]:
+        #     * ETag [String] - etag of new object
+        #     * LastModified [Time] - date object was last modified
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectCOPY.html
+        #
+        def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, options = {})
+          headers = { 'x-amz-copy-source' => "/#{source_bucket_name}#{object_to_path(source_object_name)}" }.merge!(options)
+          request({
+            :expects  => 200,
+            :headers  => headers,
+            :bucket_name => target_bucket_name,
+            :object_name => target_object_name,
+            :method   => 'PUT',
+            :parser   => Fog::Parsers::Storage::AWS::CopyObject.new,
+          })
+        end
+      end
+
+      class Mock # :nodoc:all
+        def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, options = {})
+          response = Excon::Response.new
+          source_bucket = self.data[:buckets][source_bucket_name]
+          source_object = source_bucket && source_bucket[:objects][source_object_name] && source_bucket[:objects][source_object_name].first
+          target_bucket = self.data[:buckets][target_bucket_name]
+
+          acl = options['x-amz-acl'] || 'private'
+          if !['private', 'public-read', 'public-read-write', 'authenticated-read'].include?(acl)
+            raise Excon::Errors::BadRequest.new('invalid x-amz-acl')
+          else
+            self.data[:acls][:object][target_bucket_name] ||= {}
+            self.data[:acls][:object][target_bucket_name][target_object_name] = self.class.acls(acl)
+          end
+
+          if source_object && target_bucket
+            response.status = 200
+            target_object = source_object.dup
+            target_object.merge!({'Key' => target_object_name})
+            target_bucket[:objects][target_object_name] = [target_object]
+            response.body = {
+              'ETag'          => target_object['ETag'],
+              'LastModified'  => Time.parse(target_object['Last-Modified'])
+            }
+          else
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/storage/cors_utils.rb

@@ -0,0 +1,39 @@
+module Fog
+  module Storage
+    class AWS
+      require 'fog/aws/parsers/storage/cors_configuration'
+
+      private
+
+        def self.hash_to_cors(cors)
+          data =  "<CORSConfiguration>\n"
+
+          [cors['CORSConfiguration']].flatten.compact.each do |rule|
+            data << "  <CORSRule>\n"
+
+            ['ID', 'MaxAgeSeconds'].each do |key|
+              data << "    <#{key}>#{rule[key]}</#{key}>\n" if rule[key]
+            end
+
+            ['AllowedOrigin', 'AllowedMethod', 'AllowedHeader', 'ExposeHeader'].each do |key|
+              [rule[key]].flatten.compact.each do |value|
+                data << "    <#{key}>#{value}</#{key}>\n"
+              end
+            end
+
+            data << "  </CORSRule>\n"
+          end
+
+          data << "</CORSConfiguration>"
+
+          data
+        end
+
+        def self.cors_to_hash(cors_xml)
+          parser = Fog::Parsers::Storage::AWS::CorsConfiguration.new
+          Nokogiri::XML::SAX::Parser.new(parser).parse(cors_xml)
+          parser.response
+        end
+    end
+  end
+end

data/lib/fog/aws/requests/storage/delete_bucket.rb

@@ -0,0 +1,42 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+        # Delete an S3 bucket
+        #
+        # @param bucket_name [String] name of bucket to delete
+        #
+        # @return [Excon::Response] response:
+        #   * status [Integer] - 204
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketDELETE.html
+
+        def delete_bucket(bucket_name)
+          request({
+            :expects  => 204,
+            :headers  => {},
+            :bucket_name => bucket_name,
+            :method   => 'DELETE'
+          })
+        end
+      end
+
+      class Mock # :nodoc:all
+        def delete_bucket(bucket_name)
+          response = Excon::Response.new
+          if self.data[:buckets][bucket_name].nil?
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 204}, response))
+          elsif self.data[:buckets][bucket_name] && !self.data[:buckets][bucket_name][:objects].empty?
+            response.status = 409
+            raise(Excon::Errors.status_error({:expects => 204}, response))
+          else
+            self.data[:buckets].delete(bucket_name)
+            response.status = 204
+          end
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/storage/delete_bucket_cors.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+        # Deletes the cors configuration information set for the bucket.
+        #
+        # @param bucket_name [String] name of bucket to delete cors rules from
+        #
+        # @return [Excon::Response] response:
+        #   * status [Integer] - 204
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketDELETEcors.html
+
+        def delete_bucket_cors(bucket_name)
+          request({
+            :expects  => 204,
+            :headers  => {},
+            :bucket_name => bucket_name,
+            :method   => 'DELETE',
+            :query    => {'cors' => nil}
+          })
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/storage/delete_bucket_lifecycle.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+        # Delete lifecycle configuration for a bucket
+        #
+        # @param bucket_name [String] name of bucket to delete lifecycle configuration from
+        #
+        # @return [Excon::Response] response:
+        #   * status [Integer] - 204
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketDELETElifecycle.html
+
+        def delete_bucket_lifecycle(bucket_name)
+          request({
+                    :expects  => 204,
+                    :headers  => {},
+                    :bucket_name => bucket_name,
+                    :method   => 'DELETE',
+                    :query    => {'lifecycle' => nil}
+                  })
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/storage/delete_bucket_policy.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+        # Delete policy for a bucket
+        #
+        # @param bucket_name [String] name of bucket to delete policy from
+        #
+        # @return [Excon::Response] response:
+        #   * status [Integer] - 204
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketDELETEpolicy.html
+
+        def delete_bucket_policy(bucket_name)
+          request({
+            :expects  => 204,
+            :headers  => {},
+            :bucket_name => bucket_name,
+            :method   => 'DELETE',
+            :query    => {'policy' => nil}
+          })
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/storage/delete_bucket_tagging.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+        # Delete tagging for a bucket
+        #
+        # @param bucket_name [String] name of bucket to delete tagging from
+        #
+        # @return [Excon::Response] response:
+        #   * status [Integer] - 204
+        #
+        # @see http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETEtagging.html
+
+        def delete_bucket_tagging(bucket_name)
+          request({
+            :expects  => 204,
+            :headers  => {},
+            :bucket_name => bucket_name,
+            :method   => 'DELETE',
+            :query    => {'tagging' => nil}
+          })
+        end
+      end
+
+      class Mock # :nodoc:all
+        def delete_bucket_tagging(bucket_name)
+          response = Excon::Response.new
+          if self.data[:buckets][bucket_name]
+            self.data[:bucket_tagging].delete(bucket_name)
+            response.status = 204
+          else
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 204}, response))
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/storage/delete_bucket_website.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+        # Delete website configuration for a bucket
+        #
+        # @param bucket_name [String] name of bucket to delete website configuration from
+        #
+        # @return [Excon::Response] response:
+        #   * status [Integer] - 204
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketDELETEwebsite.html
+
+        def delete_bucket_website(bucket_name)
+          request({
+            :expects  => 204,
+            :headers  => {},
+            :bucket_name => bucket_name,
+            :method   => 'DELETE',
+            :query    => {'website' => nil}
+          })
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/storage/delete_multiple_objects.rb

@@ -0,0 +1,164 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+        require 'fog/aws/parsers/storage/delete_multiple_objects'
+
+        # Delete multiple objects from S3
+        # @note For versioned deletes, options should include a version_ids hash, which
+        #     maps from filename to an array of versions.
+        #     The semantics are that for each (object_name, version) tuple, the
+        #     caller must insert the object_name and an associated version (if
+        #     desired), so for n versions, the object must be inserted n times.
+        #
+        # @param bucket_name [String] Name of bucket containing object to delete
+        # @param object_names [Array]  Array of object names to delete
+        #
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * DeleteResult [Array]:
+        #       * Deleted [Hash]:
+        #         * Key [String] - Name of the object that was deleted
+        #         * VersionId [String] - ID for the versioned onject in case of a versioned delete
+        #         * DeleteMarker [Boolean] - Indicates if the request accessed a delete marker
+        #         * DeleteMarkerVersionId [String] - Version ID of the delete marker accessed
+        #       * Error [Hash]:
+        #         * Key [String] - Name of the object that failed to be deleted
+        #         * VersionId [String] - ID of the versioned object that was attempted to be deleted
+        #         * Code [String] - Status code for the result of the failed delete
+        #         * Message [String] - Error description
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/multiobjectdeleteapi.html
+
+        def delete_multiple_objects(bucket_name, object_names, options = {})
+          headers = options.dup
+          data = "<Delete>"
+          data << "<Quiet>true</Quiet>" if headers.delete(:quiet)
+          version_ids = headers.delete('versionId')
+          object_names.each do |object_name|
+            data << "<Object>"
+            data << "<Key>#{CGI.escapeHTML(object_name)}</Key>"
+            object_version = version_ids.nil? ? nil : version_ids[object_name]
+            if object_version
+              data << "<VersionId>#{CGI.escapeHTML(object_version)}</VersionId>"
+            end
+            data << "</Object>"
+          end
+          data << "</Delete>"
+
+          headers['Content-Length'] = data.length
+          headers['Content-MD5'] = Base64.encode64(Digest::MD5.digest(data)).
+                                   gsub("\n", '')
+
+          request({
+            :body       => data,
+            :expects    => 200,
+            :headers    => headers,
+            :bucket_name => bucket_name,
+            :method     => 'POST',
+            :parser     => Fog::Parsers::Storage::AWS::DeleteMultipleObjects.new,
+            :query      => {'delete' => nil}
+          })
+        end
+      end
+
+      class Mock # :nodoc:all
+        def delete_multiple_objects(bucket_name, object_names, options = {})
+          headers = options.dup
+          headers.delete(:quiet)
+          response = Excon::Response.new
+          if bucket = self.data[:buckets][bucket_name]
+            response.status = 200
+            response.body = { 'DeleteResult' => [] }
+            version_ids = headers.delete('versionId')
+            object_names.each do |object_name|
+              object_version = version_ids.nil? ? nil : version_ids[object_name]
+              response.body['DeleteResult'] << delete_object_helper(bucket,
+                                                                object_name,
+                                                                object_version)
+            end
+          else
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+
+        private
+
+        def delete_object_helper(bucket, object_name, version_id)
+          response = { 'Deleted' => {} }
+          if bucket[:versioning]
+            bucket[:objects][object_name] ||= []
+
+            if version_id
+              version = bucket[:objects][object_name].find { |object| object['VersionId'] == version_id}
+
+              # S3 special cases the 'null' value to not error out if no such version exists.
+              if version || (version_id == 'null')
+                bucket[:objects][object_name].delete(version)
+                bucket[:objects].delete(object_name) if bucket[:objects][object_name].empty?
+
+                response['Deleted'] = { 'Key' => object_name,
+                                        'VersionId' => version_id,
+                                        'DeleteMarker' => 'true',
+                                        'DeleteMarkerVersionId' => version_id
+                                      }
+              else
+                response = delete_error_body(object_name,
+                                             version_id,
+                                             'InvalidVersion',
+                                             'Invalid version ID specified')
+              end
+            else
+              delete_marker = {
+                :delete_marker    => true,
+                'Key'             => object_name,
+                'VersionId'       => bucket[:versioning] == 'Enabled' ? Fog::Mock.random_base64(32) : 'null',
+                'Last-Modified'   => Fog::Time.now.to_date_header
+              }
+
+              # When versioning is suspended, a delete marker is placed if the last object ID is not the value 'null',
+              # otherwise the last object is replaced.
+              if bucket[:versioning] == 'Suspended' && bucket[:objects][object_name].first['VersionId'] == 'null'
+                bucket[:objects][object_name].shift
+              end
+
+              bucket[:objects][object_name].unshift(delete_marker)
+
+              response['Deleted'] = { 'Key' => object_name,
+                                      'VersionId' => delete_marker['VersionId'],
+                                      'DeleteMarkerVersionId' =>
+                                          delete_marker['VersionId'],
+                                      'DeleteMarker' => 'true',
+                                    }
+            end
+          else
+            if version_id && version_id != 'null'
+              response = delete_error_body(object_name,
+                                           version_id,
+                                           'InvalidVersion',
+                                           'Invalid version ID specified')
+              response = invalid_version_id_payload(version_id)
+            else
+              bucket[:objects].delete(object_name)
+              response['Deleted'] = { 'Key' => object_name }
+            end
+          end
+          response
+        end
+
+        def delete_error_body(key, version_id, message, code)
+          {
+            'Error' => {
+              'Code'      => code,
+              'Message'   => message,
+              'VersionId' => version_id,
+              'Key'       => key,
+            }
+          }
+        end
+      end
+    end
+  end
+end