fog 1.26.0 → 1.27.0

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

@@ -1,87 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

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

@@ -1,18 +0,0 @@
-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

@@ -1,141 +0,0 @@
-require 'fog/aws/core'
-
-module Fog
-  module AWS
-    class SES < Fog::Service
-      extend Fog::AWS::CredentialFetcher::ServiceMethods
-
-      class InvalidParameterError < Fog::Errors::Error; end
-      class MessageRejected < Fog::Errors::Error; end
-
-      requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :instrumentor, :instrumentor_name
-
-      request_path 'fog/aws/requests/ses'
-      request :delete_verified_email_address
-      request :verify_email_address
-      request :verify_domain_identity
-      request :get_send_quota
-      request :get_send_statistics
-      request :list_verified_email_addresses
-      request :send_email
-      request :send_raw_email
-
-      class Mock
-        def initialize(options={})
-          Fog::Mock.not_implemented
-        end
-      end
-
-      class Real
-        include Fog::AWS::CredentialFetcher::ConnectionMethods
-        # Initialize connection to SES
-        #
-        # ==== Notes
-        # options parameter must include values for :aws_access_key_id and
-        # :aws_secret_access_key in order to create a connection
-        #
-        # ==== Examples
-        #   ses = SES.new(
-        #    :aws_access_key_id => your_aws_access_key_id,
-        #    :aws_secret_access_key => your_aws_secret_access_key
-        #   )
-        #
-        # ==== Parameters
-        # * options<~Hash> - config arguments for connection.  Defaults to {}.
-        #   * region<~String> - optional region to use. For instance, 'us-east-1' and etc.
-        #
-        # ==== Returns
-        # * SES object with connection to AWS.
-        def initialize(options={})
-
-          @use_iam_profile = options[:use_iam_profile]
-          setup_credentials(options)
-
-          @instrumentor       = options[:instrumentor]
-          @instrumentor_name  = options[:instrumentor_name] || 'fog.aws.ses'
-          @connection_options     = options[:connection_options] || {}
-          options[:region] ||= 'us-east-1'
-          @host = options[:host] || "email.#{options[:region]}.amazonaws.com"
-          @path       = options[:path]        || '/'
-          @persistent = options[:persistent]  || false
-          @port       = options[:port]        || 443
-          @scheme     = options[:scheme]      || 'https'
-          @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
-        end
-
-        def reload
-          @connection.reset
-        end
-
-        private
-
-        def setup_credentials(options)
-          @aws_access_key_id      = options[:aws_access_key_id]
-          @aws_secret_access_key  = options[:aws_secret_access_key]
-          @aws_session_token     = options[:aws_session_token]
-          @aws_credentials_expire_at = options[:aws_credentials_expire_at]
-
-          @hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
-        end
-
-        def request(params)
-          refresh_credentials_if_expired
-
-          idempotent  = params.delete(:idempotent)
-          parser      = params.delete(:parser)
-
-          headers = {
-            'Content-Type'  => 'application/x-www-form-urlencoded',
-            'Date'          => Fog::Time.now.to_date_header,
-          }
-          headers['x-amz-security-token'] = @aws_session_token if @aws_session_token
-          #AWS3-HTTPS AWSAccessKeyId=<Your AWS Access Key ID>, Algorithm=HmacSHA256, Signature=<Signature>
-          headers['X-Amzn-Authorization'] = 'AWS3-HTTPS '
-          headers['X-Amzn-Authorization'] << 'AWSAccessKeyId=' << @aws_access_key_id
-          headers['X-Amzn-Authorization'] << ', Algorithm=HmacSHA256'
-          headers['X-Amzn-Authorization'] << ', Signature=' << Base64.encode64(@hmac.sign(headers['Date'])).chomp!
-
-          body = ''
-          for key in params.keys.sort
-            unless (value = params[key]).nil?
-              body << "#{key}=#{CGI.escape(value.to_s).gsub(/\+/, '%20')}&"
-            end
-          end
-          body.chop! # remove trailing '&'
-
-          if @instrumentor
-            @instrumentor.instrument("#{@instrumentor_name}.request", params) do
-              _request(body, headers, idempotent, parser)
-            end
-          else
-            _request(body, headers, idempotent, parser)
-          end
-        end
-
-        def _request(body, headers, idempotent, parser)
-          @connection.request({
-            :body       => body,
-            :expects    => 200,
-            :headers    => headers,
-            :idempotent => idempotent,
-            :host       => @host,
-            :method     => 'POST',
-            :parser     => parser
-          })
-        rescue Excon::Errors::HTTPStatusError => error
-          match = Fog::AWS::Errors.match_error(error)
-          raise if match.empty?
-          raise case match[:code]
-                when 'MessageRejected'
-                  Fog::AWS::SES::MessageRejected.slurp(error, match[:message])
-                when 'InvalidParameterValue'
-                  Fog::AWS::SES::InvalidParameterError.slurp(error, match[:message])
-                else
-                  Fog::AWS::SES::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
-                end
-        end
-      end
-    end
-  end
-end