aws-sdk 1.1.3 → 1.1.4

data/lib/aws/core/http/handler.rb

@@ -0,0 +1,77 @@
+# Copyright 2011 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
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# 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 AWS
+  module Core
+    module Http
+      
+      # @private
+      class Handler
+  
+        attr_reader :base
+  
+        def initialize(base, &block)
+          @base = base
+          if base.respond_to?(:handle)
+  
+            unless block.arity == 2
+              raise ArgumentError, 'passed block must accept 2 arguments'
+            end
+            MetaUtils.extend_method(self, :handle, &block)
+  
+          elsif base.respond_to?(:handle_async)
+  
+            unless block.arity == 3
+              raise ArgumentError, 'passed block must accept 3 arguments'
+            end
+  
+            MetaUtils.extend_method(self, :handle_async) do |req, resp, handle|
+              @base.handle_async(req, resp, handle)
+            end
+            MetaUtils.extend(self) do
+              define_method(:handle) do |req, resp|
+                raise "attempted to call #handle on an async handler"
+              end
+              define_method(:handle_async, &block)
+            end
+  
+          else
+            raise ArgumentError, 'base must respond to #handle or #handle_async'
+          end
+        end
+  
+        def handle(request, http_response)
+          @base.handle(request, http_response)
+        end
+  
+        def handle_async(request, http_response, handle)
+          Thread.new do
+            begin
+              self.handle(request, http_response)
+            rescue => e
+              handle.signal_failure
+            else
+              handle.signal_success
+            end
+          end
+        end
+  
+        def sleep_with_callback seconds, &block
+          Kernel.sleep(seconds)
+          yield
+        end
+  
+      end
+    end
+  end
+end

data/lib/aws/core/http/httparty_handler.rb

@@ -0,0 +1,113 @@
+# Copyright 2011 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
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# 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.
+
+require 'httparty'
+
+module AWS
+  module Core
+    module Http
+  
+      # Makes HTTP requests using HTTParty.  This is the default
+      # handler, so you don't need to do anything special to configure
+      # it.  However, you can directly instantiate this class in order
+      # to send extra options to HTTParty, for example to enable an HTTP
+      # proxy:
+      #
+      #   AWS.config(
+      #     :http_handler => AWS::Http::HTTPartyHandler.new(
+      #       :http_proxyaddr => "http://myproxy.com",
+      #       :http_proxyport => 80
+      #     )
+      #   )
+      #
+      class HTTPartyHandler
+  
+        # @return [Hash] The default options to send to HTTParty on each
+        #   request.
+        attr_reader :default_request_options
+  
+        # Constructs a new HTTP handler using HTTParty.
+        #
+        # @param [Hash] options Default options to send to HTTParty on
+        #   each request.  These options will be sent to +get+, +post+,
+        #   +head+, +put+, or +delete+ when a request is made.  Note
+        #   that +:body+, +:headers+, +:parser+, and +:ssl_ca_file+ are
+        #   ignored.  If you need to set the CA file, you should use the
+        #   +:ssl_ca_file+ option to {AWS.config} or
+        #   {AWS::Configuration} instead.
+        def initialize options = {}
+          @default_request_options = options
+        end
+  
+        include HTTParty
+  
+        class NoOpParser < HTTParty::Parser
+          SupportedFormats = {}
+        end
+  
+        def handle(request, response)
+  
+          opts = default_request_options.merge({
+            :body => request.body,
+            :parser => NoOpParser
+          })
+  
+          if request.proxy_uri
+            opts[:http_proxyaddr] = request.proxy_uri.host
+            opts[:http_proxyport] = request.proxy_uri.port
+          end
+  
+          if request.use_ssl?
+            url = "https://#{request.host}:443#{request.uri}"
+            opts[:ssl_ca_file] = request.ssl_ca_file if
+              request.ssl_verify_peer?
+          else
+            url = "http://#{request.host}#{request.uri}"
+          end
+  
+          # get, post, put, delete, head
+          method = request.http_method.downcase
+  
+          # Net::HTTP adds this header for us when the body is
+          # provided, but it messes up signing
+          headers = { 'content-type' => '' }
+  
+          # headers must have string values (net http calls .strip on them)
+          request.headers.each_pair do |key,value|
+            headers[key] = value.to_s
+          end
+  
+          opts[:headers] = headers
+  
+          begin
+            http_response = self.class.send(method, url, opts)
+          rescue Timeout::Error, Errno::ETIMEDOUT => e
+            response.timeout = true
+          else
+            response.body = http_response.body
+            response.status = http_response.code.to_i
+            response.headers = http_response.to_hash
+          end
+        end
+      end
+    end
+  end
+
+  # We move this from AWS::Http to AWS::Core::Http, but we want the 
+  # previous default handler to remain accessible from its old namesapce
+  # @private
+  module Http
+    class HTTPartyHandler < Core::Http::HTTPartyHandler; end
+  end
+
+end

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

@@ -0,0 +1,124 @@
+# Copyright 2011 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
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# 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.
+
+require 'net/http'
+require 'net/https'
+require 'openssl'
+
+module AWS
+  module Core
+    module Http
+  
+      # The default http request handler for the aws-sdk gem.  It is based
+      # on Net::Http.
+      class NetHttpHandler
+  
+        def handle request, response
+          http_session_for(request) do |http|
+            begin
+              http_resp = http.request(build_request(request))
+              response.body = http_resp.body
+              response.status = http_resp.code.to_i
+              response.headers = http_resp.to_hash
+            rescue Timeout::Error, Errno::ETIMEDOUT => e
+              response.timeout = true
+            end
+          end
+        end
+          
+        # @private
+        protected
+        def http_session_for request, &block
+          begin
+            http = build_http(request)
+            http.start
+            yield(http)
+          ensure
+            http.finish if http.started?
+          end
+        end
+
+        # @private
+        protected
+        def build_http request
+
+          http_args = []
+          http_args << request.host
+          http_args << (request.use_ssl? ? 443 : 80)
+
+          ## add proxy arguments
+
+          if proxy = request.proxy_uri
+            proxy_addr = proxy.respond_to?(:request_uri) ?
+              "#{proxy.host}#{proxy.request_uri}" : proxy.host
+            http_args << proxy_addr
+            http_args << proxy.port
+            http_args << proxy.user
+            http_args << proxy.password
+          end
+
+          # ruby 1.8.7 does not accept a hash of options at the end of
+          # Net::HTTP.new like 1.9 does, therefore we have to set ssl
+          # options on the returned http object
+          http = Net::HTTP.new(*http_args)
+
+          ## configure ssl 
+
+          if request.use_ssl?
+            http.use_ssl = true
+            if request.ssl_verify_peer?
+              http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+              http.ca_file = request.ssl_ca_file
+            else
+              http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            end
+          else
+            http.use_ssl = false
+          end
+
+          http
+
+        end
+
+        # @private
+        protected
+        def build_request request
+
+          # Net::HTTP adds a content-type header automatically unless its set
+          # and this messes with request signature signing.  Also, it expects
+          # all header values to be strings (it call strip on them).
+          headers = { 'content-type' => '' }
+          request.headers.each_pair do |key,value|
+            headers[key] = value.to_s
+          end
+
+          req_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 raise "unsupported http method: #{request.http_method}"
+          end
+
+          net_http_req = req_class.new(request.uri, headers)
+          net_http_req.body = request.body
+          net_http_req
+
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,207 @@
+# Copyright 2011 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
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# 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 AWS
+  module Core
+    module Http
+  
+      # Base class for all service reqeusts.
+      class Request
+  
+        # Returns a new empty http request object.
+        def initialize
+          @host = nil
+          @http_method = 'POST'
+          @path = '/'
+          @headers = CaseInsensitiveHash.new
+          @params = []
+          @use_ssl = true
+        end
+  
+        # @return [String] hostname of the request
+        attr_accessor :host
+  
+        # @return [CaseInsensitiveHash] request headers
+        attr_reader :headers
+  
+        # @return [Array] An array of request params, each param responds to
+        #   #name and #value.
+        attr_reader :params
+  
+        # @return [String] GET, PUT POST, HEAD or DELETE, defaults to POST
+        attr_accessor :http_method
+  
+        # @return [String] path of the request URI, defaults to /
+        attr_reader :path
+  
+        # @return [String] the AWS access key ID used to authorize the
+        #   request
+        attr_accessor :access_key_id
+  
+        # @return [nil, URI] The URI to the proxy server requests are 
+        #   sent through if configured.  Returns nil if there is no proxy.
+        attr_accessor :proxy_uri
+  
+        # @param [Boolean] ssl If the request should be sent over ssl or not.
+        def use_ssl= use_ssl
+          @use_ssl = use_ssl
+        end
+  
+        # @return [Boolean] If this request should be sent over ssl or not.
+        def use_ssl?
+          @use_ssl
+        end
+  
+        # @param [Boolean] verify_peer If the client should verify the
+        #   peer certificate or not.
+        def ssl_verify_peer=(verify_peer)
+          @ssl_verify_peer = verify_peer
+        end
+  
+        # @return [Boolean] If the client should verify the peer
+        #   certificate or not.
+        def ssl_verify_peer?
+          @ssl_verify_peer
+        end
+  
+        # @param [String] ca_file Path to a bundle of CA certs in PEM
+        #   format; the HTTP handler should use this to verify all HTTPS
+        #   requests if {#ssl_verify_peer?} is true.
+        def ssl_ca_file=(ca_file)
+          @ssl_ca_file = ca_file
+        end
+  
+        # @return [String] Path to a bundle of CA certs in PEM format;
+        #   the HTTP handler should use this to verify all HTTPS
+        #   requests if {#ssl_verify_peer?} is true.
+        def ssl_ca_file
+          @ssl_ca_file
+        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
+        #
+        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
+  
+        # @private
+        def get_param param_name
+          @params.detect{|p| p.name == param_name } ||
+            raise("undefined param #{param_name}")
+        end
+  
+        # @return [String] the request uri
+        def uri
+          querystring ? "#{path}?#{querystring}" : path
+        end
+  
+        # @return [String] Returns the request params url encoded, or nil if 
+        #   this request has no params.
+        def url_encoded_params
+          if @params.empty?
+            nil
+          else
+            @params.sort.collect{|p| p.encoded }.join('&')
+          end
+        end
+  
+        # @return [String, nil] Returns the requesty querystring.
+        def querystring
+          nil
+        end
+  
+        # @return [String, nil] Returns the request body.
+        def body
+          url_encoded_params
+        end
+  
+        # @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.
+        # @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
+            if value
+              "#{name}=#{value}"
+            else
+              name
+            end
+          end
+  
+          def ==(other)
+            other.kind_of?(Param) &&
+              to_s == other.to_s
+          end
+  
+          def encoded
+            if value
+              "#{escape(name)}=#{escape(value)}"
+            else
+              escape(name)
+            end
+          end
+  
+        end
+  
+      end
+    end
+  end
+end