mss-sdk 1.0.0

data/lib/mss/core/http/net_http_handler.rb

@@ -0,0 +1,144 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module MSS
+  module Core
+    module Http
+
+      # # NetHttpHandler
+      #
+      # This is the default HTTP handler for the mss-sdk gem.  It uses
+      # Ruby's Net::HTTP to make requests.  It uses persistent connections
+      # and a connection pool.
+      #
+      class NetHttpHandler
+
+        class TruncatedBodyError < IOError; end
+
+        # @api private
+        NETWORK_ERRORS = [
+          SocketError, EOFError, IOError, Timeout::Error,
+          Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE,
+          Errno::EINVAL, Errno::ETIMEDOUT, Errno::EHOSTUNREACH,
+          OpenSSL::SSL::SSLError
+        ]
+
+        # (see ConnectionPool.new)
+        def initialize options = {}
+          @pool = options[:connection_pool] || ConnectionPool.new(options)
+          @verify_content_length = options[:verify_response_body_content_length]
+        end
+
+        # @return [ConnectionPool]
+        attr_reader :pool
+
+        # Given a populated request object and an empty response object,
+        # this method will make the request and them populate the
+        # response.
+        # @param [Request] request
+        # @param [Response] response
+        # @return [nil]
+        def handle request, response, &read_block
+          retry_possible = true
+
+          begin
+
+            @pool.session_for(request.endpoint) do |http|
+
+              http.read_timeout = request.read_timeout
+              http.continue_timeout = request.continue_timeout if
+                http.respond_to?(:continue_timeout=)
+
+              exp_length = nil
+              act_length = 0
+              http.request(build_net_http_request(request)) do |net_http_resp|
+                response.status = net_http_resp.code.to_i
+                response.headers = net_http_resp.to_hash
+                exp_length = determine_expected_content_length(response)
+                if block_given? and response.status < 300
+                  net_http_resp.read_body do |data|
+                    begin
+                      act_length += data.bytesize
+                      yield data unless data.empty?
+                    ensure
+                      retry_possible = false
+                    end
+                  end
+                else
+                  response.body = net_http_resp.read_body
+                  act_length += response.body.bytesize unless response.body.nil?
+                end
+              end
+              run_check = exp_length && request.http_method != "HEAD" && @verify_content_length
+              if run_check && act_length != exp_length
+                raise TruncatedBodyError, 'content-length does not match'
+              end
+            end
+
+          rescue *NETWORK_ERRORS => error
+            raise error unless retry_possible
+            response.network_error = error
+          end
+          nil
+        end
+
+        protected
+
+        def determine_expected_content_length response
+          if header = response.headers['content-length']
+            if header.is_a?(Array)
+              header.first.to_i
+            end
+          end
+        end
+
+        # Given an MSS::Core::HttpRequest, this method translates
+        # it into a Net::HTTPRequest (Get, Put, Post, Head or Delete).
+        # @param [Request] request
+        # @return [Net::HTTPRequest]
+        def build_net_http_request request
+
+          # Net::HTTP adds a content-type (1.8.7+) and accept-encoding (2.0.0+)
+          # to the request if these headers are not set.  Setting a default
+          # empty value defeats this.
+          #
+          # Removing these are necessary for most services to no break request
+          # signatures as well as dynamodb crc32 checks (these fail if the
+          # response is gzipped).
+          headers = { 'content-type' => '', 'accept-encoding' => '' }
+
+          request.headers.each_pair do |key,value|
+            headers[key] = value.to_s
+          end
+
+          request_class = case request.http_method
+            when 'GET'    then Net::HTTP::Get
+            when 'PUT'    then Net::HTTP::Put
+            when 'POST'   then Net::HTTP::Post
+            when 'HEAD'   then Net::HTTP::Head
+            when 'DELETE' then Net::HTTP::Delete
+            else
+              msg = "unsupported http method: #{request.http_method}"
+              raise ArgumentError, msg
+            end
+
+          net_http_req = request_class.new(request.uri, headers)
+          net_http_req.body_stream = request.body_stream
+          net_http_req
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/mss/core/http/patch.rb

@@ -0,0 +1,98 @@
+require 'net/http'
+
+module MSS
+  module Core
+    module Http
+      # @api private
+      module Patches
+
+        def self.apply!
+          if RUBY_VERSION >= '2.0'
+            Net::HTTP.send(:include, Ruby_2)
+          elsif RUBY_VERSION >= '1.9.3'
+            Net::HTTP.send(:include, Ruby_1_9_3)
+          end
+          if RUBY_VERSION >= '1.9.3'
+            Net::HTTP.send(:alias_method, :old_transport_request, :transport_request)
+            Net::HTTP.send(:alias_method, :transport_request, :new_transport_request)
+          end
+        end
+
+        module Ruby_2
+          def new_transport_request(req)
+            count = 0
+            begin
+              begin_transport req
+              res = catch(:response) {
+                req.exec @socket, @curr_http_version, edit_path(req.path)
+                begin
+                  res = Net::HTTPResponse.read_new(@socket)
+                  res.decode_content = req.decode_content
+                end while res.kind_of?(Net::HTTPContinue)
+
+                res.uri = req.uri
+
+                res
+              }
+              res.reading_body(@socket, req.response_body_permitted?) {
+                yield res if block_given?
+              }
+            rescue Net::OpenTimeout
+              raise
+            rescue Net::ReadTimeout, IOError, EOFError,
+                   Errno::ECONNRESET, Errno::ECONNABORTED, Errno::EPIPE,
+                   # avoid a dependency on OpenSSL
+                   defined?(OpenSSL::SSL) ? OpenSSL::SSL::SSLError : IOError,
+                   Timeout::Error => exception
+              if count == 0 && Net::HTTP::IDEMPOTENT_METHODS_.include?(req.method)
+                count += 1
+                @socket.close if @socket and not @socket.closed?
+                D "Conn close because of error #{exception}, and retry"
+                if req.body_stream
+                  if req.body_stream.respond_to?(:rewind)
+                    req.body_stream.rewind
+                  else
+                    raise
+                  end
+                end
+                retry
+              end
+              D "Conn close because of error #{exception}"
+              @socket.close if @socket and not @socket.closed?
+              raise
+            end
+
+            end_transport req, res
+            res
+          rescue => exception
+            D "Conn close because of error #{exception}"
+            @socket.close if @socket and not @socket.closed?
+            raise exception
+          end
+        end
+
+        module Ruby_1_9_3
+          def new_transport_request(req)
+            begin_transport req
+            res = catch(:response) {
+              req.exec @socket, @curr_http_version, edit_path(req.path)
+              begin
+                res = Net::HTTPResponse.read_new(@socket)
+              end while res.kind_of?(Net::HTTPContinue)
+              res
+            }
+            res.reading_body(@socket, req.response_body_permitted?) {
+              yield res if block_given?
+            }
+            end_transport req, res
+            res
+          rescue => exception
+            D "Conn close because of error #{exception}"
+            @socket.close if @socket and not @socket.closed?
+            raise exception
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mss/core/http/request.rb

@@ -0,0 +1,258 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module MSS
+  module Core
+    module Http
+
+      # Base class for all service reqeusts.  This class describes
+      # a basic HTTP request, but will not make one.  It is consumed
+      # by a HTTP handler class that sends the actual request
+      # and parses the actual response.
+      class Request
+
+        extend Deprecations
+
+        # Returns a new empty http request object.
+        def initialize
+          @http_method = 'POST'
+          @use_ssl = true
+          @headers = CaseInsensitiveHash.new
+          @uri = '/'
+          @params = []
+          @read_timeout = 60
+        end
+
+        # @return [String] hostname of the request
+        attr_accessor :host
+
+        # @return [Integer] Returns the port number this request will be
+        #   made via (usually 443 or 80).
+        attr_accessor :port
+
+        # @return [String] Returns the HTTP request method (e.g. 'GET', 'PUT',
+        #   'POST', 'HEAD' or 'DELETE').  Defaults to 'POST'.
+        attr_accessor :http_method
+
+        # @return [CaseInsensitiveHash] request headers
+        attr_accessor :headers
+
+        # @return [String] Returns the request URI (path + querystring).
+        attr_accessor :uri
+
+        # @return [String] The region name this request is for.  Only needs
+        #   to be populated for requests against signature v4 endpoints.
+        attr_accessor :region
+
+        # @api private
+        attr_accessor :service
+
+        # @return [String] Returns the MSS access key ID used to authorize the
+        #   request.
+        # @api private
+        attr_accessor :access_key_id
+
+        # @return [Array<Param>] Returns an array of request params.  Requests
+        #   that use signature version 2 add params to the request and then
+        #   sign those before building the {#body}.  Normally the {#body}
+        #   should be set directly with the HTTP payload.
+        # @api private
+        attr_accessor :params
+
+        # @return [String] The name of the service for Signature v4 signing.
+        #   This does not always match the ruby name (e.g.
+        #   simple_email_service and ses do not match).
+        attr_accessor :service_ruby_name
+
+        # @return [Integer] The number of seconds the service has to respond
+        #   before a timeout error is raised on the request.
+        attr_accessor :read_timeout
+
+        alias_method :default_read_timeout, :read_timeout
+        deprecated :default_read_timeout, :use => :read_timeout
+
+        # @return [Boolean] Returns `true` if this request should be made
+        #   with SSL enabled.
+        attr_accessor :use_ssl
+
+        alias_method :use_ssl?, :use_ssl
+
+        # @return [Float] timeout The number of seconds to wait for a
+        #   100-continue response before sending the HTTP request body.
+        # @api private
+        attr_accessor :continue_timeout
+
+        # @api private
+        def endpoint
+          scheme = use_ssl ? 'https' : 'http'
+          port = case scheme
+          when 'https' then self.port == 443 ? '' : ":#{self.port}"
+          when 'http' then self.port == 80 ? '' : ":#{self.port}"
+          end
+          "#{scheme}://#{host}#{port}"
+        end
+
+        # @return [Integer] Returns the port the request will be made over.
+        #   Defaults to 443 for SSL requests and 80 for non-SSL requests.
+        def port
+          @port || (use_ssl? ? 443 : 80)
+        end
+
+        # @return [String] Returns the HTTP request path.
+        def path
+          uri.split(/\?/)[0]
+        end
+
+        # @return [String] Returns the HTTP request querystring.
+        def querystring
+          uri.split(/\?/)[1]
+        end
+
+        # Adds a request param.
+        #
+        # @overload add_param(param_name, param_value = nil)
+        #   Add a param (name/value)
+        #   @param [String] param_name
+        #   @param [String] param_value Leave blank for sub resources
+        #
+        # @overload add_param(param_obj)
+        #   Add a param (object)
+        #   @param [Param] param_obj
+        #
+        # @api private
+        def add_param name_or_param, value = nil
+          if name_or_param.kind_of?(Param)
+            @params << name_or_param
+          else
+            @params << Param.new(name_or_param, value)
+          end
+        end
+
+        # @api private
+        def remove_param(name)
+          if param = @params.find { |p| p.name == name }
+            @params.delete(param)
+          end
+        end
+
+        # @api private
+        # @return [String,nil] Returns the url encoded request params.  If there
+        #   are no params, then nil is returned.
+        def url_encoded_params
+          params.empty? ? nil : params.sort.collect(&:encoded).join('&')
+        end
+
+        # @param [String] body
+        def body= body
+          @body = body
+          if body
+            headers['content-length'] = body.bytesize if body
+          else
+            headers.delete('content-length')
+          end
+        end
+
+        # @note Calling #body on a request with a #body_stream
+        #   will cause the entire stream to be read into memory.
+        # @return [String,nil] Returns the request body.
+        def body
+          if @body
+            @body
+          elsif @body_stream
+            @body = @body_stream.read
+            if @body_stream.respond_to?(:rewind)
+              @body_stream.rewind
+            else
+              @body_stream = StringIO.new(@body)
+            end
+            @body
+          else
+            nil
+          end
+        end
+
+        # Sets the request body as an IO object that will be streamed.
+        # @note You must also set the #headers['content-length']
+        # @param [IO] stream An object that responds to #read and #eof.
+        def body_stream= stream
+          @body_stream = stream
+        end
+
+        # @return [IO,nil]
+        def body_stream
+          if @body_stream
+            @body_stream
+          elsif @body
+            StringIO.new(@body)
+          else
+            nil
+          end
+        end
+
+        # @api private
+        class CaseInsensitiveHash < Hash
+
+          def []= key, value
+            super(key.to_s.downcase, value)
+          end
+
+          def [] key
+            super(key.to_s.downcase)
+          end
+
+          def has_key?(key)
+            super(key.to_s.downcase)
+          end
+          alias_method :key?, :has_key?
+          alias_method :include?, :has_key?
+          alias_method :member?, :has_key?
+
+        end
+
+        # Represents a single request paramater.  Some services accept this
+        # in a form encoded body string, others as query parameters.
+        # It is up to each service's Request class to determine how to
+        # consume these params.
+        # @api private
+        class Param
+
+          include UriEscape
+
+          attr_accessor :name, :value
+
+          def initialize name, value = nil
+            @name = name
+            @value = value
+          end
+
+          def <=> other
+            name <=> other.name
+          end
+
+          def to_s
+            value ? "#{name}=#{value}" : name
+          end
+
+          def ==(other)
+            other.kind_of?(Param) and to_s == other.to_s
+          end
+
+          def encoded
+            value ? "#{escape(name)}=#{escape(value)}" : "#{escape(name)}="
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/mss/core/http/response.rb

@@ -0,0 +1,80 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module MSS
+  module Core
+    module Http
+
+      # Represents the http response from a service request.
+      #
+      # Responses have:
+      #
+      # * status (200, 404, 500, etc)
+      # * headers (hash of response headers)
+      # * body (the response body)
+      class Response
+
+        # @return [Integer] Returns the http response status code.
+        attr_accessor :status
+
+        # @return [Hash] ({}) Returns the HTTP response headers.
+        attr_accessor :headers
+
+        # @return [String,nil] Returns the HTTP response body.
+        attr_accessor :body
+
+        # @return [Exception,nil]
+        attr_accessor :network_error
+
+        # @return [Boolean] Returns `true` if the request could not be made
+        #   because of a networking issue (including timeouts).
+        def network_error?
+          @network_error ? true : false
+        end
+
+        # The #network_error attribute was previously #timeout, aliasing
+        # for backwards compatability
+        alias_method :timeout=, :network_error=
+
+        # @param [Hash] options
+        # @option options [Integer] :status (200) HTTP status code
+        # @option options [Hash] :headers ({}) HTTP response headers
+        # @option options [String] :body ('') HTTP response body
+        def initialize options = {}, &block
+          @status = options[:status] || 200
+          @headers = options[:headers] || {}
+          @body = options[:body]
+          yield(self) if block_given?
+          self
+        end
+
+        # Returns the header value with the given name.
+        #
+        # The value is matched case-insensitively so if the headers hash
+        # contains a key like 'Date' and you request the value for
+        # 'date' the 'Date' value will be returned.
+        #
+        # @param [String,Symbol] name The name of the header to fetch a value for.
+        # @return [String,nil] The value of the given header
+        def header name
+          headers.each_pair do |header_name, header_value|
+            if header_name.downcase == name.to_s.downcase
+              return header_value.is_a?(Array) ? header_value.first : header_value
+            end
+          end
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/mss/core/indifferent_hash.rb

@@ -0,0 +1,87 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module MSS
+  module Core
+
+    # A utility class to provide indifferent access to hash data.
+    #
+    # Inspired by ActiveSupport's HashWithIndifferentAccess, this class
+    # has a few notable differences:
+    #
+    # * ALL keys are converted to strings (via #to_s)
+    # * It does not deep merge/convert hashes indifferently, good for fla
+    # * It will not perserve default value behaviours
+    #
+    # These features were omitted because our primary use for this class is to
+    # wrap a 1-level hash as a return value, but we want the user to access
+    # the values with string or symbol keys.
+    #
+    # @api private
+    class IndifferentHash < Hash
+
+      def initialize *args
+        if args.first.is_a?(Hash)
+          super()
+          merge!(*args)
+        else
+          super(*args)
+        end
+      end
+
+      alias_method :_getter, :[]
+      alias_method :_setter, :[]=
+
+      def []=(key, value)
+        _setter(_convert_key(key), value)
+      end
+      alias_method :store, :[]=
+
+      def [] key
+        _getter(_convert_key(key))
+      end
+
+      def merge! hash
+        hash.each_pair do |key,value|
+          self[key] = value
+        end
+        self
+      end
+      alias_method :update, :merge!
+
+      def merge hash
+        self.dup.merge!(hash)
+      end
+
+      def has_key? key
+        super(_convert_key(key))
+      end
+      alias_method :key?, :has_key?
+      alias_method :member?, :has_key?
+      alias_method :include?, :has_key?
+
+      def fetch key, *extras, &block
+        super(_convert_key(key), *extras, &block)
+      end
+
+      def delete key
+        super(_convert_key(key))
+      end
+
+      private
+      def _convert_key key
+        key.is_a?(String) ? key : key.to_s
+      end
+
+    end
+  end
+end