fog 1.1.2 → 1.2.0

data/lib/fog/aws/requests/sns/set_topic_attributes.rb

@@ -21,7 +21,7 @@ module Fog
             'Action'          => 'SetTopicAttributes',
             'AttributeName'   => attribute_name,
             'AttributeValue'  => attribute_value,
-            'TopicArn'        => arn,
+            'TopicArn'        => arn.strip,
             :parser     => Fog::Parsers::AWS::SNS::SetTopicAttributes.new
           })
         end

data/lib/fog/aws/requests/sns/subscribe.rb

@@ -21,7 +21,7 @@ module Fog
             'Action'    => 'Subscribe',
             'Endpoint'  => endpoint,
             'Protocol'  => protocol,
-            'TopicArn'  => arn,
+            'TopicArn'  => arn.strip,
             :parser     => Fog::Parsers::AWS::SNS::Subscribe.new
           })
         end

data/lib/fog/aws/requests/sns/unsubscribe.rb

@@ -17,7 +17,7 @@ module Fog
         def unsubscribe(arn)
           request({
             'Action'          => 'Unsubscribe',
-            'SubscriptionArn' => arn,
+            'SubscriptionArn' => arn.strip,
             :parser           => Fog::Parsers::AWS::SNS::Unsubscribe.new
           })
         end

data/lib/fog/aws/requests/sqs/change_message_visibility.rb

@@ -34,7 +34,7 @@ module Fog
           Excon::Response.new.tap do |response|
             if (queue = data[:queues][queue_url])
               message_id, _ = queue[:receipt_handles].find { |message_id, receipts|
-                receipts.keys.include?(receipt_handle)
+                receipts.has_key?(receipt_handle)
               }
               
               if message_id

data/lib/fog/aws/requests/sqs/delete_message.rb

@@ -32,7 +32,7 @@ module Fog
           Excon::Response.new.tap do |response|
             if (queue = data[:queues][queue_url])
               message_id, _ = queue[:receipt_handles].find { |msg_id, receipts|
-                receipts.keys.include?(receipt_handle)
+                receipts.has_key?(receipt_handle)
               }
 
               if message_id

data/lib/fog/aws/requests/sqs/receive_message.rb

@@ -37,37 +37,36 @@ module Fog
               max_number_of_messages = options['MaxNumberOfMessages'] || 1
               now = Time.now
               
-              keys = queue[:messages].keys[0, max_number_of_messages]
-              
-              messages = queue[:messages].values_at(*keys).map do |m|
+              messages = []
+
+              queue[:messages].values.each do |m|
                 message_id = m['MessageId']
-                
+
                 invisible = if (received_handles = queue[:receipt_handles][message_id])
                   visibility_timeout = m['Attributes']['VisibilityTimeout'] || queue['Attributes']['VisibilityTimeout']
                   received_handles.any? { |handle, time| now < time + visibility_timeout }
                 else
                   false
                 end
-                
-                if invisible
-                  nil
-                else
+
+                unless invisible
                   receipt_handle = Fog::Mock.random_base64(300)
-                  
+
                   queue[:receipt_handles][message_id] ||= {}
                   queue[:receipt_handles][message_id][receipt_handle] = now
-                  
+
                   m['Attributes'].tap do |attrs|
                     attrs['ApproximateFirstReceiveTimestamp'] ||= now
                     attrs['ApproximateReceiveCount'] = (attrs['ApproximateReceiveCount'] || 0) + 1
                   end
-                  
-                  m.merge({
+
+                  messages << m.merge({
                     'ReceiptHandle' => receipt_handle
                   })
+                  break if messages.size >= max_number_of_messages
                 end
-              end.compact
-              
+              end
+
               response.body = {
                 'ResponseMetadata' => {
                   'RequestId' => Fog::AWS::Mock.request_id

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

@@ -48,7 +48,7 @@ module Fog
         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_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'
@@ -62,10 +62,8 @@ module Fog
           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
+            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'])

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

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

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

@@ -17,6 +17,12 @@ module Fog
         # http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectDELETE.html
 
         def delete_object(bucket_name, object_name, options = {})
+          if version_id = options.delete('versionId')
+            path = "#{CGI.escape(object_name)}?versionId=#{CGI.escape(version_id)}"
+          else
+            path = CGI.escape(object_name)
+          end
+
           headers = options
           request({
             :expects    => 204,
@@ -24,7 +30,7 @@ module Fog
             :host       => "#{bucket_name}.#{@host}",
             :idempotent => true,
             :method     => 'DELETE',
-            :path       => CGI.escape(object_name)
+            :path       => path
           })
         end
 
@@ -36,7 +42,57 @@ module Fog
           response = Excon::Response.new
           if bucket = self.data[:buckets][bucket_name]
             response.status = 204
-            bucket[:objects].delete(object_name)
+
+            version_id = options.delete('versionId')
+
+            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.headers['x-amz-delete-marker'] = 'true' if version[:delete_marker]
+                  response.headers['x-amz-version-id'] = version_id
+                else
+                  response.status = 400
+                  response.body = invalid_version_id_payload(version_id)
+                  raise(Excon::Errors.status_error({:expects => 200}, response))
+                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.headers['x-amz-delete-marker'] = 'true'
+                response.headers['x-amz-version-id'] = delete_marker['VersionId']
+              end
+            else
+              if version_id && version_id != 'null'
+                response.status = 400
+                response.body = invalid_version_id_payload(version_id)
+                raise(Excon::Errors.status_error({:expects => 200}, response))
+              else
+                bucket[:objects].delete(object_name)
+
+                response.headers['x-amz-version-id'] = 'null'
+              end
+            end
           else
             response.status = 404
             raise(Excon::Errors.status_error({:expects => 204}, response))
@@ -44,6 +100,21 @@ module Fog
           response
         end
 
+        private
+
+        def invalid_version_id_payload(version_id)
+          {
+            'Error' => {
+              'Code' => 'InvalidArgument',
+              'Message' => 'Invalid version id specified',
+              'ArgumentValue' => version_id,
+              'ArgumentName' => 'versionId',
+              'RequestId' => Fog::Mock.random_hex(16),
+              'HostId' => Fog::Mock.random_base64(65)
+            }
+          }
+        end
+
       end
     end
   end

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

@@ -69,11 +69,12 @@ module Fog
           end
           response = Excon::Response.new
           if bucket = self.data[:buckets][bucket_name]
-            contents = bucket[:objects].values.sort {|x,y| x['Key'] <=> y['Key']}.reject do |object|
+            contents = bucket[:objects].values.collect(&:first).sort {|x,y| x['Key'] <=> y['Key']}.reject do |object|
                 (prefix    && object['Key'][0...prefix.length] != prefix) ||
                 (marker    && object['Key'] <= marker) ||
                 (delimiter && object['Key'][(prefix ? prefix.length : 0)..-1].include?(delimiter) \
-                           && common_prefixes << object['Key'].sub(/^(#{prefix}[^#{delimiter}]+.).*/, '\1'))
+                           && common_prefixes << object['Key'].sub(/^(#{prefix}[^#{delimiter}]+.).*/, '\1')) ||
+                object.has_key?(:delete_marker)
               end.map do |object|
                 data = object.reject {|key, value| !['ETag', 'Key', 'StorageClass'].include?(key)}
                 data.merge!({

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

@@ -0,0 +1,41 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/storage/get_bucket_lifecycle'
+
+        # Get bucket lifecycle configuration
+        #
+        # ==== Parameters
+        # * bucket_name<~String> - name of bucket to get lifecycle configuration for
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'Rules'<~Array> - object expire rules
+        #        * 'ID'<~String>      - Unique identifier for the rule
+        #        * 'Prefix'<~String>  - Prefix identifying one or more objects to which the rule applies
+        #        * 'Enabled'<~Boolean> - if rule is currently being applied
+        #        * 'Days'<~Integer>   - lifetime, in days, of the objects that are subject to the rule
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETlifecycle.html
+
+        def get_bucket_lifecycle(bucket_name)
+          request({
+                    :expects  => 200,
+                    :headers  => {},
+                    :host     => "#{bucket_name}.#{@host}",
+                    :idempotent => true,
+                    :method   => 'GET',
+                    :parser   => Fog::Parsers::Storage::AWS::GetBucketLifecycle.new,
+                    :query    => {'lifecycle' => nil}
+                  })
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -65,11 +65,104 @@ module Fog
             :idempotent => true,
             :method   => 'GET',
             :parser   => Fog::Parsers::Storage::AWS::GetBucketObjectVersions.new,
-            :query    => {'versions' => nil}.merge!(options)
-          })
+            :query    => {'versions' => nil}.merge!(options)          })
         end
 
       end
+
+      class Mock
+        def get_bucket_object_versions(bucket_name, options = {})
+          delimiter, key_marker, max_keys, prefix, version_id_marker = \
+            options['delimiter'], options['key-marker'], options['max-keys'],options['prefix'],options['version-id-marker']
+
+          unless bucket_name
+            raise ArgumentError.new('bucket_name is required')
+          end
+
+          response = Excon::Response.new
+
+          # Invalid arguments.
+          if version_id_marker && !key_marker
+            response.status = 400
+            response.body = {
+              'Error' => {
+                'Code' => 'InvalidArgument',
+                'Message' => 'A version-id marker cannot be specified without a key marker.',
+                'ArgumentValue' => version_id_marker,
+                'RequestId' => Fog::Mock.random_hex(16),
+                'HostId' => Fog::Mock.random_base64(65)
+              }
+            }
+
+          # Valid case.
+          # TODO: (nirvdrum 12/15/11) It's not clear to me how to actually use version-id-marker, so I didn't implement it below.
+          elsif bucket = self.data[:buckets][bucket_name]
+            # We need to order results by S3 key, but since our data store is key => [versions], we want to ensure the integrity
+            # of the versions as well.  So, sort the keys, then fetch the versions, and then combine them all as a sorted list by
+            # flattening the results.
+            contents = bucket[:objects].keys.sort.collect { |key| bucket[:objects][key] }.flatten.reject do |object|
+                (prefix      && object['Key'][0...prefix.length] != prefix) ||
+                (key_marker  && object['Key'] <= key_marker) ||
+                (delimiter   && object['Key'][(prefix ? prefix.length : 0)..-1].include?(delimiter) \
+                             && common_prefixes << object['Key'].sub(/^(#{prefix}[^#{delimiter}]+.).*/, '\1'))
+              end.map do |object|
+                if object.has_key?(:delete_marker)
+                  tag_name = 'DeleteMarker'
+                  extracted_attrs = ['Key', 'VersionId']
+                else
+                  tag_name = 'Version'
+                  extracted_attrs = ['ETag', 'Key', 'StorageClass', 'VersionId']
+                end
+
+                data = {}
+                data[tag_name] = object.reject { |key, value| !extracted_attrs.include?(key) }
+                data[tag_name].merge!({
+                  'LastModified' => Time.parse(object['Last-Modified']),
+                  'Owner'        => bucket['Owner'],
+                  'IsLatest'     => object == bucket[:objects][object['Key']].first
+                })
+
+                data[tag_name]['Size'] = object['Content-Length'].to_i if tag_name == 'Version'
+              data
+            end
+
+            max_keys = max_keys || 1000
+            size = [max_keys, 1000].min
+            truncated_contents = contents[0...size]
+
+            response.status = 200
+            response.body = {
+              'Versions'        => truncated_contents,
+              'IsTruncated'     => truncated_contents.size != contents.size,
+              'KeyMarker'       => key_marker,
+              'VersionIdMarker' => version_id_marker,
+              'MaxKeys'         => max_keys,
+              'Name'            => bucket['Name'],
+              'Prefix'          => prefix
+            }
+            if max_keys && max_keys < response.body['Versions'].length
+                response.body['IsTruncated'] = true
+                response.body['Versions'] = response.body['Versions'][0...max_keys]
+            end
+
+          # Missing bucket case.
+          else
+            response.status = 404
+            response.body = {
+              'Error' => {
+                'Code' => 'NoSuchBucket',
+                'Message' => 'The specified bucket does not exist',
+                'BucketName' => bucket_name,
+                'RequestId' => Fog::Mock.random_hex(16),
+                'HostId' => Fog::Mock.random_base64(65)
+              }
+            }
+
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+      end
     end
   end
 end

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

@@ -33,7 +33,39 @@ module Fog
             :query      => {'versioning' => nil}
           })
         end
+      end
+
+      class Mock
+        def get_bucket_versioning(bucket_name)
+          response = Excon::Response.new
+          bucket = self.data[:buckets][bucket_name]
+
+          if bucket
+            response.status = 200
+
+            if bucket[:versioning]
+              response.body = { 'VersioningConfiguration' => { 'Status' => bucket[:versioning] } }
+            else
+              response.body = { 'VersioningConfiguration' => {} }
+            end
 
+          else
+            response.status = 404
+            response.body = {
+              'Error' => {
+                'Code' => 'NoSuchBucket',
+                'Message' => 'The specified bucket does not exist',
+                'BucketName' => bucket_name,
+                'RequestId' => Fog::Mock.random_hex(16),
+                'HostId' => Fog::Mock.random_base64(65)
+              }
+            }
+
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+
+          response
+        end
       end
     end
   end