fog 1.1.1 → 1.2.0

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

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

@@ -35,26 +35,30 @@ module Fog
           unless object_name
             raise ArgumentError.new('object_name is required')
           end
+
+          params = { :headers => {} }
           if version_id = options.delete('versionId')
-            query = {'versionId' => version_id}
+            params[:query] = {'versionId' => version_id}
+          end
+          params[:headers].merge!(options)
+          if options['If-Modified-Since']
+            params[:headers]['If-Modified-Since'] = Fog::Time.at(options['If-Modified-Since'].to_i).to_date_header
           end
-          headers = {}
-          headers.merge!(options)
-          if headers['If-Modified-Since']
-            headers['If-Modified-Since'] = Fog::Time.at(headers['If-Modified-Since'].to_i).to_date_header
+          if options['If-Unmodified-Since']
+            params[:headers]['If-Unmodified-Since'] = Fog::Time.at(options['If-Unmodified-Since'].to_i).to_date_header
           end
-          if headers['If-Unmodified-Since']
-            headers['If-Unmodified-Since'] = Fog::Time.at(headers['If-Unmodified-Since'].to_i).to_date_header
+
+          if block_given?
+            params[:response_block] = Proc.new
           end
-          request({
+
+          request(params.merge!({
             :expects  => [ 200, 206 ],
-            :headers  => headers,
             :host     => "#{bucket_name}.#{@host}",
             :idempotent => true,
             :method   => 'GET',
             :path     => CGI.escape(object_name),
-            :query    => query
-          }, &block)
+          }))
         end
 
       end
@@ -62,15 +66,24 @@ module Fog
       class Mock # :nodoc:all
 
         def get_object(bucket_name, object_name, options = {}, &block)
+          version_id = options.delete('versionId')
+
           unless bucket_name
             raise ArgumentError.new('bucket_name is required')
           end
+
           unless object_name
             raise ArgumentError.new('object_name is required')
           end
+
           response = Excon::Response.new
           if (bucket = self.data[:buckets][bucket_name])
-            if (object = bucket[:objects][object_name])
+            object = nil
+            if bucket[:objects].has_key?(object_name)
+              object = version_id ? bucket[:objects][object_name].find { |object| object['VersionId'] == version_id} : bucket[:objects][object_name].first
+            end
+
+            if (object && !object[:delete_marker])
               if options['If-Match'] && options['If-Match'] != object['ETag']
                 response.status = 412
               elsif options['If-Modified-Since'] && options['If-Modified-Since'] > Time.parse(object['Last-Modified'])
@@ -87,6 +100,9 @@ module Fog
                     response.headers[key] = value
                   end
                 end
+
+                response.headers['x-amz-version-id'] = object['VersionId'] if bucket[:versioning]
+
                 unless block_given?
                   response.body = object[:body]
                 else
@@ -99,6 +115,20 @@ module Fog
                   end
                 end
               end
+            elsif version_id && !object
+              response.status = 400
+              response.body = {
+                '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)
+                }
+              }
+
+              raise(Excon::Errors.status_error({:expects => 200}, response))
             else
               response.status = 404
               response.body = "...<Code>NoSuchKey<\/Code>..."

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

@@ -59,11 +59,17 @@ module Fog
 
       class Mock # :nodoc:all
 
+        require 'fog/aws/requests/storage/acl_utils'
+
         def get_object_acl(bucket_name, object_name, options = {})
           response = Excon::Response.new
           if acl = self.data[:acls][:object][bucket_name] && self.data[:acls][:object][bucket_name][object_name]
             response.status = 200
-            response.body = acl
+            if acl.is_a?(String)
+              response.body = Fog::Storage::AWS.acl_to_hash(acl)
+            else
+              response.body = acl
+            end
           else
             response.status = 404
             raise(Excon::Errors.status_error({:expects => 200}, response))

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

@@ -4,18 +4,24 @@ module Fog
 
       module GetObjectHttpUrl
 
-        def get_object_http_url(bucket_name, object_name, expires)
+        def get_object_http_url(bucket_name, object_name, expires, options = {})
           unless bucket_name
             raise ArgumentError.new('bucket_name is required')
           end
           unless object_name
             raise ArgumentError.new('object_name is required')
           end
+          host, path = if bucket_name =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\.(?![\.\-])|\-(?![\.])){1,61}[a-z0-9]$/
+            ["#{bucket_name}.s3.amazonaws.com", object_name]
+          else
+            ['s3.amazonaws.com', "#{bucket_name}/#{object_name}"]
+          end
           http_url({
             :headers  => {},
-            :host     => @host,
+            :host     => host,
             :method   => 'GET',
-            :path     => "#{bucket_name}/#{object_name}"
+            :path     => path,
+            :query    => options[:query]
           }, expires)
         end
 
@@ -48,4 +54,4 @@ module Fog
       end
     end
   end
-end
+end

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

@@ -4,18 +4,24 @@ module Fog
 
       module GetObjectHttpsUrl
 
-        def get_object_https_url(bucket_name, object_name, expires)
+        def get_object_https_url(bucket_name, object_name, expires, options = {})
           unless bucket_name
             raise ArgumentError.new('bucket_name is required')
           end
           unless object_name
             raise ArgumentError.new('object_name is required')
           end
+          host, path = if bucket_name =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\.(?![\.\-])|\-(?![\.])){1,61}[a-z0-9]$/
+            ["#{bucket_name}.s3.amazonaws.com", object_name]
+          else
+            ['s3.amazonaws.com', "#{bucket_name}/#{object_name}"]
+          end
           https_url({
             :headers  => {},
-            :host     => @host,
+            :host     => host,
             :method   => 'GET',
-            :path     => "#{bucket_name}/#{object_name}"
+            :path     => path,
+            :query    => options[:query]
           }, expires)
         end
 
@@ -48,4 +54,4 @@ module Fog
       end
     end
   end
-end
+end

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

@@ -43,12 +43,13 @@ module Fog
           headers['If-Unmodified-Since'] = Fog::Time.at(options['If-Unmodified-Since'].to_i).to_date_header if options['If-Modified-Since']
           headers.merge!(options)
           request({
-            :expects  => 200,
-            :headers  => headers,
-            :host     => "#{bucket_name}.#{@host}",
-            :method   => 'HEAD',
-            :path     => CGI.escape(object_name),
-            :query    => query
+            :expects    => 200,
+            :headers    => headers,
+            :host       => "#{bucket_name}.#{@host}",
+            :idempotent => true,
+            :method     => 'HEAD',
+            :path       => CGI.escape(object_name),
+            :query      => query
           })
         end
 

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

@@ -3,8 +3,8 @@ module Fog
     class AWS
       class Real
 
-        require 'fog/aws/requests/storage/hash_to_acl'
-      
+        require 'fog/aws/requests/storage/acl_utils'
+
         # Change access control list for an S3 bucket
         #
         # ==== Parameters

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

@@ -0,0 +1,48 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+
+        # Change lifecycle configuration for an S3 bucket
+        #
+        # ==== Parameters
+        # * bucket_name<~String> - name of bucket to set lifecycle configuration for
+        # * lifecycle<~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/RESTBucketPUTlifecycle.html
+
+        def put_bucket_lifecycle(bucket_name, lifecycle)
+          builder = Nokogiri::XML::Builder.new do
+            LifecycleConfiguration {
+              lifecycle['Rules'].each do |rule|
+                Rule {
+                  ID rule['ID']
+                  Prefix rule['Prefix']
+                  Status rule['Enabled'] ? 'Enabled' : 'Disabled'
+                  Expiration { Days rule['Days'] }
+                }
+              end
+            }
+          end
+
+          body = builder.to_xml
+
+          request({
+                    :body     => body,
+                    :expects  => 200,
+                    :headers  => {'Content-MD5' => Base64.encode64(Digest::MD5.digest(body)).chomp!,
+                      'Content-Type' => 'application/xml'},
+                    :host     => "#{bucket_name}.#{@host}",
+                    :method   => 'PUT',
+                    :query    => {'lifecycle' => nil}
+                  })
+        end
+      end
+    end
+  end
+end

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

@@ -29,7 +29,48 @@ DATA
             :query    => {'versioning' => nil}
           })
         end
+      end
+
+      class Mock
+        def put_bucket_versioning(bucket_name, status)
+          response = Excon::Response.new
+          bucket = self.data[:buckets][bucket_name]
+
+          if bucket
+            if ['Enabled', 'Suspended'].include?(status)
+              bucket[:versioning] = status
 
+              response.status = 200
+            else
+              response.status = 400
+              response.body = {
+                'Error' => {
+                  'Code' => 'MalformedXML',
+                  'Message' => 'The XML you provided was not well-formed or did not validate against our published schema',
+                  'RequestId' => Fog::Mock.random_hex(16),
+                  'HostId' => Fog::Mock.random_base64(65)
+                }
+              }
+
+              raise(Excon::Errors.status_error({:expects => 200}, response))
+            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

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

@@ -44,6 +44,23 @@ DATA
         end
 
       end
+
+      class Mock # :nodoc:all
+
+        def put_bucket_website(bucket_name, suffix, options = {})
+          response = Excon::Response.new
+          if self.data[:buckets][bucket_name]
+            response.status = 200
+          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/put_object.rb

@@ -32,9 +32,9 @@ module Fog
         def put_object(bucket_name, object_name, data, options = {})
           data = Fog::Storage.parse_data(data)
           headers = data[:headers].merge!(options)
-          request({
-            :body       => data[:body],
-            :expects    => 200,
+          request({            :body       => data[:body],
+                      :expects    => 200,
+
             :headers    => headers,
             :host       => "#{bucket_name}.#{@host}",
             :idempotent => true,
@@ -66,11 +66,12 @@ module Fog
             object = {
               :body             => data[:body],
               'Content-Type'    => options['Content-Type'] || data[:headers]['Content-Type'],
-              'ETag'            => Fog::AWS::Mock.etag,
+              'ETag'            => Digest::MD5.hexdigest(data[:body]),
               'Key'             => object_name,
               'Last-Modified'   => Fog::Time.now.to_date_header,
               'Content-Length'  => options['Content-Length'] || data[:headers]['Content-Length'],
-              'StorageClass'    => options['x-amz-storage-class'] || 'STANDARD'
+              'StorageClass'    => options['x-amz-storage-class'] || 'STANDARD',
+              'VersionId'       => bucket[:versioning] == 'Enabled' ? Fog::Mock.random_base64(32) : 'null'
             }
 
             for key, value in options
@@ -80,13 +81,28 @@ module Fog
               end
             end
 
-            bucket[:objects][object_name] = object
+            if bucket[:versioning]
+              bucket[:objects][object_name] ||= []
+
+              # When versioning is suspended, putting an object will create a new 'null' version if the latest version
+              # is a value other than 'null', otherwise it will replace the latest version.
+              if bucket[:versioning] == 'Suspended' && bucket[:objects][object_name].first['VersionId'] == 'null'
+                bucket[:objects][object_name].shift
+              end
+
+              bucket[:objects][object_name].unshift(object)
+            else
+              bucket[:objects][object_name] = [object]
+            end
+
             response.headers = {
-              'Content-Length'  => object['Content-Length'],
-              'Content-Type'    => object['Content-Type'],
-              'ETag'            => object['ETag'],
-              'Last-Modified'   => object['Last-Modified']
+              'Content-Length'   => object['Content-Length'],
+              'Content-Type'     => object['Content-Type'],
+              'ETag'             => object['ETag'],
+              'Last-Modified'    => object['Last-Modified'],
             }
+
+            response.headers['x-amz-version-id'] = object['VersionId'] if object['VersionId'] != 'null'
           else
             response.status = 404
             raise(Excon::Errors.status_error({:expects => 200}, response))

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

@@ -3,7 +3,7 @@ module Fog
     class AWS
       class Real
 
-        require 'fog/aws/requests/storage/hash_to_acl'
+        require 'fog/aws/requests/storage/acl_utils'
 
         # Change access control list for an S3 object
         #

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

@@ -8,7 +8,7 @@ module Fog
         def sync_clock
           response = begin
             get_service
-          rescue => error
+          rescue Excon::Errors::HTTPStatusError => error
             error.response
           end
           Fog::Time.now = Time.parse(response.headers['Date'])

data/lib/fog/aws/requests/sts/get_federation_token.rb

@@ -0,0 +1,21 @@
+module Fog
+  module AWS
+    class STS
+      class Real
+
+        require 'fog/aws/parsers/sts/get_session_token'
+
+        def get_federation_token(name, policy, duration=43200)
+          request({
+            'Action'          => 'GetFederationToken',
+            'Name'            => name,
+            'Policy'          => MultiJson.encode(policy),
+            'DurationSeconds' => duration,
+            :idempotent       => true,
+            :parser           => Fog::Parsers::AWS::STS::GetSessionToken.new
+          })
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/sts/get_session_token.rb

@@ -0,0 +1,19 @@
+module Fog
+  module AWS
+    class STS
+      class Real
+
+        require 'fog/aws/parsers/sts/get_session_token'
+
+        def get_session_token(duration=43200)
+          request({
+            'Action'          => 'GetSessionToken',
+            'DurationSeconds' => duration,
+            :idempotent       => true,
+            :parser           => Fog::Parsers::AWS::STS::GetSessionToken.new
+          })
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/ses.rb

@@ -40,7 +40,7 @@ module Fog
         #
         # ==== Parameters
         # * options<~Hash> - config arguments for connection.  Defaults to {}.
-        #   * region<~String> - optional region to use, in ['eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2', 'ap-southeast-1']
+        #   * region<~String> - optional region to use. For instance, 'us-east-1' and etc.
         #
         # ==== Returns
         # * SES object with connection to AWS.
@@ -52,12 +52,7 @@ module Fog
           @connection_options     = options[:connection_options] || {}
           @hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
           options[:region] ||= 'us-east-1'
-          @host = options[:host] || case options[:region]
-          when 'us-east-1'
-            'email.us-east-1.amazonaws.com'
-          else
-            raise ArgumentError, "Unknown region: #{options[:region].inspect}"
-          end
+          @host = options[:host] || "email.#{options[:region]}.amazonaws.com"
           @path       = options[:path]        || '/'
           @persistent = options[:persistent]  || false
           @port       = options[:port]        || 443