fog-aws 0.0.5

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

@@ -0,0 +1,78 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+        require 'fog/aws/requests/storage/acl_utils'
+
+        # Change access control list for an S3 object
+        #
+        # @param [String] bucket_name name of bucket to modify
+        # @param [String] object_name name of object to get access control list for
+        # @param [Hash] acl
+        #   * Owner [Hash]
+        #     * ID [String] id of owner
+        #     * DisplayName [String] display name of owner
+        #   * AccessControlList [Array]
+        #     * Grantee [Hash]
+        #       * DisplayName [String] Display name of grantee
+        #       * ID [String] Id of grantee
+        #       or
+        #       * EmailAddress [String] Email address of grantee
+        #       or
+        #       * URI [String] URI of group to grant access for
+        #     * Permission [String] Permission, in [FULL_CONTROL, WRITE, WRITE_ACP, READ, READ_ACP]
+        # @param [String] acl Permissions, must be in ['private', 'public-read', 'public-read-write', 'authenticated-read']
+        # @param [Hash] options
+        # @option options [String] versionId specify a particular version to retrieve
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectPUTacl.html
+
+        def put_object_acl(bucket_name, object_name, acl, options = {})
+          query = {'acl' => nil}
+          if version_id = options.delete('versionId')
+            query['versionId'] = version_id
+          end
+
+          data = ""
+          headers = {}
+
+          if acl.is_a?(Hash)
+            data = Fog::Storage::AWS.hash_to_acl(acl)
+          else
+            if !['private', 'public-read', 'public-read-write', 'authenticated-read'].include?(acl)
+              raise Excon::Errors::BadRequest.new('invalid x-amz-acl')
+            end
+            headers['x-amz-acl'] = acl
+          end
+
+          headers['Content-MD5'] = Base64.encode64(Digest::MD5.digest(data)).strip
+          headers['Content-Type'] = 'application/json'
+          headers['Date'] = Fog::Time.now.to_date_header
+
+          request({
+            :body     => data,
+            :expects  => 200,
+            :headers  => headers,
+            :bucket_name => bucket_name,
+            :object_name => object_name,
+            :method   => 'PUT',
+            :query    => query
+          })
+        end
+      end
+
+      class Mock
+        def put_object_acl(bucket_name, object_name, acl, options = {})
+          if acl.is_a?(Hash)
+            self.data[:acls][:object][bucket_name][object_name] = Fog::Storage::AWS.hash_to_acl(acl)
+          else
+            if !['private', 'public-read', 'public-read-write', 'authenticated-read'].include?(acl)
+              raise Excon::Errors::BadRequest.new('invalid x-amz-acl')
+            end
+            self.data[:acls][:object][bucket_name][object_name] = acl
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Fog
+  module Storage
+    class AWS
+      module PutObjectUrl
+        def put_object_url(bucket_name, object_name, expires, headers = {}, options = {})
+          unless bucket_name
+            raise ArgumentError.new('bucket_name is required')
+          end
+          unless object_name
+            raise ArgumentError.new('object_name is required')
+          end
+          signed_url(options.merge({
+            :bucket_name => bucket_name,
+            :object_name => object_name,
+            :method   => 'PUT',
+            :headers  => headers,
+          }), expires)
+        end
+      end
+
+      class Real
+        # Get an expiring object url from S3 for putting an object
+        #
+        # @param bucket_name [String] Name of bucket containing object
+        # @param object_name [String] Name of object to get expiring url for
+        # @param expires [Time] An expiry time for this url
+        #
+        # @return [Excon::Response] response:
+        #   * body [String] url for object
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/dev/S3_QSAuth.html
+
+        include PutObjectUrl
+      end
+
+      class Mock # :nodoc:all
+        include PutObjectUrl
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+        # Change who pays for requests to an S3 bucket
+        #
+        # @param bucket_name [String] name of bucket to modify
+        # @param payer [String] valid values are BucketOwner or Requester
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTrequestPaymentPUT.html
+
+        def put_request_payment(bucket_name, payer)
+          data =
+<<-DATA
+<RequestPaymentConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+  <Payer>#{payer}</Payer>
+</RequestPaymentConfiguration>
+DATA
+          request({
+            :body     => data,
+            :expects  => 200,
+            :headers  => {},
+            :bucket_name => bucket_name,
+            :method   => 'PUT',
+            :query    => {'requestPayment' => nil}
+          })
+        end
+      end
+
+      class Mock # :nodoc:all
+        def put_request_payment(bucket_name, payer)
+          response = Excon::Response.new
+          if bucket = self.data[:buckets][bucket_name]
+            response.status = 200
+            bucket['Payer'] = payer
+          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/shared_mock_methods.rb

@@ -0,0 +1,87 @@
+module Fog
+  module Storage
+    class AWS
+      module SharedMockMethods
+        def define_mock_acl(bucket_name, object_name, options)
+          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][bucket_name] ||= {}
+            self.data[:acls][:object][bucket_name][object_name] = self.class.acls(acl)
+          end
+        end
+
+        def parse_mock_data(data)
+          data = Fog::Storage.parse_data(data)
+          unless data[:body].is_a?(String)
+            data[:body] = data[:body].read
+          end
+          data
+        end
+
+        def verify_mock_bucket_exists(bucket_name)
+          if (bucket = self.data[:buckets][bucket_name])
+            return bucket
+          end
+
+          response = Excon::Response.new
+          response.status = 404
+          raise(Excon::Errors.status_error({:expects => 200}, response))
+        end
+
+        def get_upload_info(bucket_name, upload_id, delete = false)
+          if delete
+            upload_info = self.data[:multipart_uploads][bucket_name].delete(upload_id)
+          else
+            upload_info = self.data[:multipart_uploads][bucket_name][upload_id]
+          end
+
+          if !upload_info
+            response = Excon::Response.new
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+
+          upload_info
+        end
+
+        def store_mock_object(bucket, object_name, body, options)
+          object = {
+            :body             => body,
+            'Content-Type'    => options['Content-Type'],
+            'ETag'            => Digest::MD5.hexdigest(body),
+            'Key'             => object_name,
+            'Last-Modified'   => Fog::Time.now.to_date_header,
+            'Content-Length'  => options['Content-Length'],
+            'StorageClass'    => options['x-amz-storage-class'] || 'STANDARD',
+            'VersionId'       => bucket[:versioning] == 'Enabled' ? Fog::Mock.random_base64(32) : 'null'
+          }
+
+          for key, value in options
+            case key
+            when 'Cache-Control', 'Content-Disposition', 'Content-Encoding', 'Content-MD5', 'Expires', /^x-amz-meta-/
+              object[key] = value
+            end
+          end
+
+          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
+
+          object
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+        # Sync clock against S3 to avoid skew errors
+        #
+        def sync_clock
+          response = begin
+            get_service
+          rescue Excon::Errors::HTTPStatusError => error
+            error.response
+          end
+          Fog::Time.now = Time.parse(response.headers['Date'])
+        end
+      end # Real
+
+      class Mock # :nodoc:all
+        def sync_clock
+          true
+        end
+      end # Mock
+    end # Storage
+  end # AWS
+end # Fog

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

@@ -0,0 +1,57 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+        # Upload a part for a multipart upload
+        #
+        # @param bucket_name [String] Name of bucket to add part to
+        # @param object_name [String] Name of object to add part to
+        # @param upload_id [String] Id of upload to add part to
+        # @param part_number [String] Index of part in upload
+        # @param data [File||String] Content for part
+        # @param options [Hash]
+        # @option options Content-MD5 [String] Base64 encoded 128-bit MD5 digest of message
+        #
+        # @return [Excon::Response] response
+        #   * headers [Hash]:
+        #     * ETag [String] etag of new object (will be needed to complete upload)
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadUploadPart.html
+        #
+        def upload_part(bucket_name, object_name, upload_id, part_number, data, options = {})
+          data = Fog::Storage.parse_data(data)
+          headers = options
+          headers['Content-Length'] = data[:headers]['Content-Length']
+          request({
+            :body       => data[:body],
+            :expects    => 200,
+            :idempotent => true,
+            :headers    => headers,
+            :bucket_name => bucket_name,
+            :object_name => object_name,
+            :method     => 'PUT',
+            :query      => {'uploadId' => upload_id, 'partNumber' => part_number}
+          })
+        end
+      end # Real
+
+      class Mock # :nodoc:all
+        require 'fog/aws/requests/storage/shared_mock_methods'
+        include Fog::Storage::AWS::SharedMockMethods
+
+        def upload_part(bucket_name, object_name, upload_id, part_number, data, options = {})
+          data = parse_mock_data(data)
+          verify_mock_bucket_exists(bucket_name)
+          upload_info = get_upload_info(bucket_name, upload_id)
+          upload_info[:parts][part_number] = data[:body]
+
+          response = Excon::Response.new
+          response.status = 200
+          # just use the part number as the ETag, for simplicity
+          response.headers["ETag"] = part_number.to_s
+          response
+        end
+      end # Mock
+    end # Storage
+  end # AWS
+end # Fog

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

@@ -0,0 +1,44 @@
+module Fog
+  module AWS
+    class STS
+      class Real
+        require 'fog/aws/parsers/sts/assume_role'
+
+        # Assume Role
+        #
+        # ==== Parameters
+        # * role_session_name<~String> - An identifier for the assumed role.
+        # * role_arn<~String> - The ARN of the role the caller is assuming.
+        # * external_id<~String> - An optional unique identifier required by the assuming role's trust identity.
+        # * policy<~String> - An optional JSON policy document
+        # * duration<~Integer> - Duration (of seconds) for the assumed role credentials to be valid (default 3600)
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'Arn'<~String>: The ARN of the assumed role/user
+        #     * 'AccessKeyId'<~String>: The AWS access key of the temporary credentials for the assumed role
+        #     * 'SecretAccessKey'<~String>: The AWS secret key of the temporary credentials for the assumed role
+        #     * 'SessionToken'<~String>: The AWS session token of the temporary credentials for the assumed role
+        #     * 'Expiration'<~Time>: The expiration time of the temporary credentials for the assumed role
+        #
+        # ==== See Also
+        # http://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html
+        #
+
+        def assume_role(role_session_name, role_arn, external_id=nil, policy=nil, duration=3600)
+          request({
+            'Action'          => 'AssumeRole',
+            'RoleSessionName' => role_session_name,
+            'RoleArn'         => role_arn,
+            'Policy'          => policy && Fog::JSON.encode(policy),
+            'DurationSeconds' => duration,
+            'ExternalId'      => external_id,
+            :idempotent       => true,
+            :parser           => Fog::Parsers::AWS::STS::AssumeRole.new
+          })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Fog
+  module AWS
+    class STS
+      class Real
+        require 'fog/aws/parsers/sts/assume_role_with_saml'
+
+        # Assume Role with SAML
+        #
+        # ==== Parameters
+        # * role_arn<~String> - The ARN of the role the caller is assuming.
+        # * principal_arn<~String> - The Amazon Resource Name (ARN) of the SAML provider in IAM that describes the IdP.
+        # * saml_assertion<~String> - The base-64 encoded SAML authentication response provided by the IdP.
+        # * policy<~String> - An optional JSON policy document
+        # * duration<~Integer> - Duration (of seconds) for the assumed role credentials to be valid (default 3600)
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'Arn'<~String>: The ARN of the assumed role/user
+        #     * 'AccessKeyId'<~String>: The AWS access key of the temporary credentials for the assumed role
+        #     * 'SecretAccessKey'<~String>: The AWS secret key of the temporary credentials for the assumed role
+        #     * 'SessionToken'<~String>: The AWS session token of the temporary credentials for the assumed role
+        #     * 'Expiration'<~Time>: The expiration time of the temporary credentials for the assumed role
+        #
+        # ==== See Also
+        # http://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html
+        #
+
+        def assume_role_with_saml(role_arn, principal_arn, saml_assertion, policy=nil, duration=3600)
+          request_unsigned({
+            'Action'          => 'AssumeRoleWithSAML',
+            'RoleArn'         => role_arn,  
+            'PrincipalArn'    => principal_arn,
+            'SAMLAssertion'   => saml_assertion,
+            'Policy'          => policy && Fog::JSON.encode(policy),
+            'DurationSeconds' => duration,
+            :idempotent       => true,
+            :parser           => Fog::Parsers::AWS::STS::AssumeRoleWithSAML.new
+          })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Fog
+  module AWS
+    class STS
+      class Real
+        require 'fog/aws/parsers/sts/get_session_token'
+
+        # Get federation token
+        #
+        # ==== Parameters
+        # * name<~String>: The name of the federated user.
+        #                  Minimum length of 2. Maximum length of 32.
+        # * policy<~String>: Optional policy that specifies the permissions
+        #                    that are granted to the federated user
+        #                    Minimum length of 1. Maximum length of 2048.
+        # * duration<~Integer>: Optional duration, in seconds, that the session
+        #                       should last.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'SessionToken'<~String> -
+        #     * 'SecretAccessKey'<~String> -
+        #     * 'Expiration'<~String> -
+        #     * 'AccessKeyId'<~String> -
+        #     * 'Arn'<~String> -
+        #     * 'FederatedUserId'<~String> -
+        #     * 'PackedPolicySize'<~String> -
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # ==== See Also
+        # http://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html
+
+        def get_federation_token(name, policy, duration=43200)
+          request({
+            'Action'          => 'GetFederationToken',
+            'Name'            => name,
+            'Policy'          => Fog::JSON.encode(policy),
+            'DurationSeconds' => duration,
+            :idempotent       => true,
+            :parser           => Fog::Parsers::AWS::STS::GetSessionToken.new
+          })
+        end
+      end
+      class Mock
+        def get_federation_token(name, policy, duration=43200)
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.body = {
+            'SessionToken'     => Fog::Mock.random_base64(580),
+            'SecretAccessKey'  => Fog::Mock.random_base64(40),
+            'Expiration'       => (DateTime.now + duration).strftime('%FT%TZ'),
+            'AccessKeyId'      => Fog::AWS::Mock.key_id(20),
+            'Arn'              => "arn:aws:sts::#{Fog::AWS::Mock.owner_id}:federated-user/#{name}",
+            'FederatedUserId'  => "#{Fog::AWS::Mock.owner_id}:#{name}",
+            'PackedPolicySize' => Fog::Mock.random_numbers(2),
+            'RequestId'        => Fog::AWS::Mock.request_id
+            }
+          end
+        end
+      end
+    end
+  end
+end