fog-aws 0.0.5

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

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

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

data/lib/fog/aws/signaturev4.rb

@@ -0,0 +1,119 @@
+require 'fog/aws/core'
+
+# See http://docs.amazonwebservices.com/general/latest/gr/signature-version-4.html
+module Fog
+  module AWS
+    class SignatureV4
+      ALGORITHM = 'AWS4-HMAC-SHA256'
+      def initialize(aws_access_key_id, secret_key, region, service)
+        @region = region
+        @service = service
+        @aws_access_key_id  = aws_access_key_id
+        @hmac = Fog::HMAC.new('sha256', 'AWS4' + secret_key)
+      end
+
+      def signature_parameters(params, date, body_sha = nil)
+        params = params.dup.merge(:query => params[:query].merge(
+          'X-Amz-Algorithm' => ALGORITHM,
+          'X-Amz-Credential' => "#{@aws_access_key_id}/#{credential_scope(date)}",
+          'X-Amz-SignedHeaders' => signed_headers(params[:headers])
+        ))
+        signature_components(params, date, body_sha)
+      end
+
+      def signature_header(params, date, body_sha = nil)
+        components_to_header(signature_components(params, date, body_sha))
+      end
+
+      def sign(params, date) #legacy method name
+        signature_header(params, date)
+      end
+
+      def components_to_header components
+        "#{components['X-Amz-Algorithm']} Credential=#{components['X-Amz-Credential']}, SignedHeaders=#{components['X-Amz-SignedHeaders']}, Signature=#{components['X-Amz-Signature']}" 
+      end
+
+      def signature_components(params, date, body_sha)
+        canonical_request = <<-DATA
+#{params[:method].to_s.upcase}
+#{canonical_path(params[:path])}
+#{canonical_query_string(params[:query])}
+#{canonical_headers(params[:headers])}
+#{signed_headers(params[:headers])}
+#{body_sha || Digest::SHA256.hexdigest(params[:body] || '')}
+DATA
+        canonical_request.chop!
+
+        string_to_sign = <<-DATA
+#{ALGORITHM}
+#{date.to_iso8601_basic}
+#{credential_scope(date)}
+#{Digest::SHA256.hexdigest(canonical_request)}
+DATA
+
+        string_to_sign.chop!
+
+        signature = derived_hmac(date).sign(string_to_sign)
+
+        {
+          'X-Amz-Algorithm' => ALGORITHM,
+          'X-Amz-Credential' => "#{@aws_access_key_id}/#{credential_scope(date)}",
+          'X-Amz-SignedHeaders' => signed_headers(params[:headers]),
+          'X-Amz-Signature' => signature.unpack('H*').first
+        }
+      end
+
+      def derived_hmac(date)
+        kDate = @hmac.sign(date.utc.strftime('%Y%m%d'))
+        kRegion = Fog::HMAC.new('sha256', kDate).sign(@region)
+        kService = Fog::HMAC.new('sha256', kRegion).sign(@service)
+        kSigning = Fog::HMAC.new('sha256', kService).sign('aws4_request')
+        Fog::HMAC.new('sha256', kSigning)
+      end
+
+
+      def credential_scope(date)
+        "#{date.utc.strftime('%Y%m%d')}/#{@region}/#{@service}/aws4_request"
+      end
+
+      protected
+
+      def canonical_path(path)
+        components = path.split(%r{/+}, -1)
+        path = components.inject([]) do |acc, component|
+          case component
+          when '.'   #canonicalize by removing .
+          when '..' then acc.pop#canonicalize by reducing ..
+          else
+            acc << component
+          end
+          acc
+        end.join('/')
+        path.empty? ? '/' : path
+      end
+
+      def canonical_query_string(query)
+        canonical_query_string = []
+        for key in (query || {}).keys.sort_by {|k| k.to_s}
+          component = "#{Fog::AWS.escape(key.to_s)}=#{Fog::AWS.escape(query[key].to_s)}"
+          canonical_query_string << component
+        end
+        canonical_query_string.join("&")
+      end
+
+      def canonical_headers(headers)
+        canonical_headers = ''
+
+        for key in headers.keys.sort_by {|k| k.to_s}
+          canonical_headers << "#{key.to_s.downcase}:#{headers[key].to_s.strip}\n"
+        end
+        canonical_headers
+      end
+
+      def signed_headers(headers)
+        headers.keys.map {|key| key.to_s}.sort.map {|key| key.downcase}.join(';')
+      end
+
+    end
+  end
+end

data/lib/fog/aws/simpledb.rb

@@ -0,0 +1,211 @@
+require 'fog/aws/core'
+
+module Fog
+  module AWS
+    class SimpleDB < Fog::Service
+      extend Fog::AWS::CredentialFetcher::ServiceMethods
+
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :host, :nil_string, :path, :port, :scheme, :persistent, :region, :aws_session_token, :use_iam_profile, :aws_credentials_expire_at, :instrumentor, :instrumentor_name
+
+      request_path 'fog/aws/requests/simpledb'
+      request :batch_put_attributes
+      request :create_domain
+      request :delete_attributes
+      request :delete_domain
+      request :domain_metadata
+      request :get_attributes
+      request :list_domains
+      request :put_attributes
+      request :select
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :domains => {}
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          @use_iam_profile = options[:use_iam_profile]
+          setup_credentials(options)
+        end
+
+        def data
+          self.class.data[@aws_access_key_id]
+        end
+
+        def reset_data
+          self.class.data.delete(@aws_access_key_id)
+        end
+
+        def setup_credentials(options)
+          @aws_access_key_id = options[:aws_access_key_id]
+        end
+      end
+
+      class Real
+        include Fog::AWS::CredentialFetcher::ConnectionMethods
+        # Initialize connection to SimpleDB
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   sdb = SimpleDB.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 {}.
+        #
+        # ==== Returns
+        # * SimpleDB object with connection to aws.
+        def initialize(options={})
+
+          @use_iam_profile = options[:use_iam_profile]
+          setup_credentials(options)
+          @connection_options     = options[:connection_options] || {}
+          @nil_string = options[:nil_string]|| 'nil'
+          @instrumentor       = options[:instrumentor]
+          @instrumentor_name  = options[:instrumentor_name] || 'fog.aws.simpledb'
+
+          options[:region] ||= 'us-east-1'
+          @host = options[:host] || case options[:region]
+          when 'us-east-1'
+            'sdb.amazonaws.com'
+          else
+            "sdb.#{options[:region]}.amazonaws.com"
+          end
+          @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
+
+        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 encode_attributes(attributes, replace_attributes = [], expected_attributes = {})
+          encoded_attributes = {}
+          if attributes
+
+            expected_attributes.keys.each_with_index do |exkey, index|
+              for value in Array(expected_attributes[exkey])
+                encoded_attributes["Expected.#{index}.Name"] = exkey.to_s
+                encoded_attributes["Expected.#{index}.Value"] = sdb_encode(value)
+              end
+            end
+
+            index = 0
+            for key in attributes.keys
+              for value in Array(attributes[key])
+                encoded_attributes["Attribute.#{index}.Name"] = key.to_s
+                if replace_attributes.include?(key)
+                  encoded_attributes["Attribute.#{index}.Replace"] = 'true'
+                end
+                encoded_attributes["Attribute.#{index}.Value"] = sdb_encode(value)
+                index += 1
+              end
+            end
+          end
+          encoded_attributes
+        end
+
+        def encode_attribute_names(attributes)
+          Fog::AWS.indexed_param('AttributeName', attributes.map {|attribute| attributes.to_s})
+        end
+
+        def encode_batch_attributes(items, replace_attributes = Hash.new([]))
+          encoded_attributes = {}
+          if items
+            item_index = 0
+            for item_key in items.keys
+              encoded_attributes["Item.#{item_index}.ItemName"] = item_key.to_s
+              attribute_index = 0
+              for attribute_key in items[item_key].keys
+                for value in Array(items[item_key][attribute_key])
+                  encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Name"] = attribute_key.to_s
+                  if replace_attributes[item_key].include?(attribute_key)
+                    encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Replace"] = 'true'
+                  end
+                  encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Value"] = sdb_encode(value)
+                  attribute_index += 1
+                end
+              end
+              item_index += 1
+            end
+          end
+          encoded_attributes
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          refresh_credentials_if_expired
+
+          idempotent = params.delete(:idempotent)
+          parser = params.delete(:parser)
+
+          body = Fog::AWS.signed_params(
+            params,
+            {
+              :aws_access_key_id  => @aws_access_key_id,
+              :aws_session_token  => @aws_session_token,
+              :hmac               => @hmac,
+              :host               => @host,
+              :path               => @path,
+              :port               => @port,
+              :version            => '2009-04-15'
+            }
+          )
+
+          if @instrumentor
+            @instrumentor.instrument("#{@instrumentor_name}.request", params) do
+              _request(body, idempotent, parser)
+            end
+          else
+            _request(body, idempotent, parser)
+          end
+        end
+
+        def _request(body, idempotent, parser)
+          @connection.request({
+            :body       => body,
+            :expects    => 200,
+            :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded; charset=utf-8' },
+            :idempotent => idempotent,
+            :method     => 'POST',
+            :parser     => parser
+          })
+        end
+
+        def sdb_encode(value)
+          if value.nil?
+            @nil_string
+          else
+            value.to_s
+          end
+        end
+      end
+    end
+  end
+end