aws_sdk 3.1.5

data/lib/aws/sts/session.rb

@@ -0,0 +1,48 @@
+# Copyright 2011-2012 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
+  class STS
+
+    # Represents a session using temporary AWS credentials.  Use
+    # {STS#new_session} or {STS#new_federated_session} to get a new
+    # set of temporary credentials.
+    class Session
+
+      # A hash containing the following keys:
+      #
+      # * +:access_key_id+
+      # * +:secret_access_key+
+      # * +:session_token+
+      #
+      # This hash may be passed as-is to {AWS.config} or to the
+      # constructor of any service interface that supports temporary
+      # security credentials from the AWS Security Token Service.
+      #
+      # @return [Hash]
+      attr_reader :credentials
+
+      # The date on which these credentials expire.
+      #
+      # @return [Time]
+      attr_reader :expires_at
+
+      # @private
+      def initialize(opts = {})
+        @credentials = opts[:credentials]
+        @expires_at = opts[:expires_at]
+      end
+
+    end
+  end
+end

data/lib/net/http/connection_pool.rb

@@ -0,0 +1,210 @@
+# Copyright 2011-2012 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/connection_pool/session'
+require 'net/http/connection_pool/connection'
+require 'thread'
+
+# @private
+class Net::HTTP::ConnectionPool
+
+  SOCKET_ERRORS = [
+    EOFError, 
+    IOError, 
+    Errno::ECONNABORTED, 
+    Errno::ECONNRESET, 
+    Errno::EPIPE, 
+    Errno::EINVAL 
+  ]
+
+  # @param [Hash] options
+  #
+  # @option options [Numeric] :idle_timeout (60) The number of seconds a 
+  #   connection is allowed to sit idle before it is closed and removed
+  #   from the pool.
+  #
+  # @option options [Numeric] :open_timeout (15) The number of seconds to 
+  #   wait when opening a http session before raising a timeout exception.
+  # 
+  def initialize options = {}
+    @pool = []
+    @pool_mutex = Mutex.new
+    @open_timeout = options[:open_timeout] || 15
+    @idle_timeout = options[:idle_timeout] || 60
+  end
+
+  # @return [Integer] 
+  attr_reader :idle_timeout
+
+  # @return [Integer]
+  attr_accessor :open_timeout
+
+  # Requests a http session from the connection pool.  
+  #
+  #   pool.connection_for('domain.com') do |connection|
+  #
+  #     # make 
+  #     connection.request(Net::HTTP::Get.new('/index.html'))
+  #     connection.request(Net::HTTP::Get.new('/about.html'))
+  #
+  #   end
+  #
+  # The yielded connection object is a thin wrapper around the persistent 
+  # http session object.  You generally want to call {Connection#request}
+  # on the yielded object.  When the block is complete the connection
+  # will be returned to the pool.
+  #
+  # @param [String] host
+  #
+  # @param [Hash] options
+  #
+  # @option options [Integer] :port Which port the connection should use.
+  #   Defaults to 80, unless +:ssl+ is +true+, then it defaults to 443.
+  #
+  # @option options [Boolean] :ssl If the connection should be made over
+  #   SSL.  Defaults to +false+, unless +:port+ is 443, then it defaults
+  #   to +true+.
+  #
+  # @option options [Boolean] :ssl_verify_peer (true) If true, ssl 
+  #   connections will verify peer certificates.  This should only ever be
+  #   set false false for debugging purposes.
+  #
+  # @option options [String] :ssl_ca_file Full path to the SSL certificate
+  #   authority bundle file that should be used when verifying peer 
+  #   certificates.  If you do not pass +:ssl_ca_file+ or +:ssl_ca_path+
+  #   the the system default will be used if available.
+  #
+  # @option options [String] :ssl_ca_path Full path of the directory that
+  #   contains the unbundled SSL certificate authority files for verifying
+  #   peer certificates.  If you do not pass +:ssl_ca_file+ or +:ssl_ca_path+
+  #   the the system default will be used if available.
+  #
+  # @option options [URI::HTTP,String] :proxy_uri (nil) A URI string or
+  #   URI::HTTP for a proxy reqeusts should be made through.  You should
+  #   not pass both +:proxy_uri+ with any of the other proxy options.
+  #
+  #     :proxy_uri => 'http://user:pass@host.com:80'
+  #
+  # @option options [String] :proxy_address
+  #
+  # @option options [String] :proxy_port
+  #
+  # @option options [String] :proxy_user
+  #
+  # @option options [String] :proxy_password
+  #
+  # @yieldparam [Connection] connection
+  #
+  # @return [nil]
+  #
+  def connection_for host, options = {}, &block
+    connection = Connection.new(self, host, options)
+    if block_given?
+      yield(connection)
+    else
+      connection
+    end
+  end
+
+  def request connection, *request_args, &block
+
+    session = nil
+    response = nil
+    retried = false
+
+    begin
+
+      session = session_for(connection, retried)
+      session.http_session.read_timeout = connection.read_timeout
+      response = session.request(*request_args, &block)
+
+    rescue Exception => error
+
+      # close the http session to prevent the connection from being
+      # left open and risk the other side sending data
+      session.finish if session
+
+      # retry socket errors once on a new session
+      if SOCKET_ERRORS.include?(error.class) and !retried
+        retried = true
+        retry
+      end
+
+      raise error
+
+    else
+      @pool_mutex.synchronize { @pool << session }
+    end
+
+    response
+
+  end
+
+  # Returns the number of sessions currently in the pool, not counting those
+  # currently in use.
+  def size
+    @pool_mutex.synchronize { @pool.size }  
+  end
+
+  # Removes stale http sessions from the pool (that have exceeded 
+  # the idle timeout).
+  def clean!
+    @pool_mutex.synchronize { _clean }
+  end
+
+  # Closes and removes removes all sessions from the pool.  
+  # If empty! is called while there are outstanding requests they may
+  # get checked back into the pool, leaving the pool in a non-empty state.
+  def empty!
+    @pool_mutex.synchronize do
+      @pool.each(&:finish)
+      @pool = []
+    end
+  end
+
+  # Returns a suitable session from the pool or creates a new one
+  private
+  def session_for connection, force_new = false
+
+    session = nil
+
+    unless force_new
+      @pool_mutex.synchronize do
+        _clean
+        session = @pool.find{|idle_session| idle_session.key == connection.key }
+        @pool.delete(session) if session
+      end
+    end
+
+    if session.nil?
+      session = Session.for(connection, open_timeout)
+    end
+
+    session
+  end
+
+  private
+  def _clean
+    now = Time.now
+    @pool.delete_if do |idle_session|
+      if 
+        idle_session.last_used_at.nil? or
+        now - idle_session.last_used_at > idle_timeout
+      then
+        idle_session.finish
+        true
+      end
+    end
+  end
+
+end

data/lib/net/http/connection_pool/connection.rb

@@ -0,0 +1,132 @@
+# Copyright 2011-2012 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 'uri'
+
+class Net::HTTP::ConnectionPool
+
+  # A light wrapper around Net::HTTP.  
+  #
+  # You should not need to construct connection objects yourself.  
+  # You receive them as a response to {ConnectionPool#connection_for}.
+  #
+  class Connection
+
+    # @param [ConnectionPool] pool
+    # @param (see ConnectionPool#connection_for) 
+    # @option (see ConnectionPool#connection_for)
+    # @return [Connection]
+    def initialize pool, host, options = {}
+
+      @pool = pool
+
+      @host = host
+
+      @port = options.key?(:port) ? options[:port] : (options[:ssl] ? 443 : 80)
+
+      @ssl = options.key?(:ssl) ? options[:ssl] : (port == 443) 
+
+      @ssl_verify_peer = options.key?(:ssl_verify_peer) ?
+        options[:ssl_verify_peer] : true
+
+      @ssl_ca_file = options[:ssl_ca_file]
+
+      @ssl_ca_path = options[:ssl_ca_path]
+
+      if uri = options[:proxy_uri]
+        uri = URI.parse(uri) if uri.is_a?(String)
+        @proxy_address = uri.host
+        @proxy_port = uri.port
+        @proxy_user = uri.user
+        @proxy_password = uri.password
+      else
+        @proxy_address = options[:proxy_address]
+        @proxy_port = options[:proxy_port]
+        @proxy_user = options[:proxy_user]
+        @proxy_password = options[:proxy_password]
+      end
+
+      @read_timeout = options[:read_timeout] || 60
+
+    end
+
+    # @return [ConnectionPool]
+    attr_reader :pool
+
+    # @return [String]
+    attr_reader :host
+
+    # @return [Integer]
+    attr_reader :port
+
+    # @return [Boolean]
+    attr_reader :ssl
+
+    # @return [Boolean]
+    attr_reader :ssl_verify_peer
+
+    # @return [String,nil]
+    attr_reader :ssl_ca_file
+
+    # @return [String,nil]
+    attr_reader :ssl_ca_path
+
+    # @return [String,nil]
+    attr_reader :proxy_address
+
+    # @return [Integer,nil]
+    attr_reader :proxy_port
+
+    # @return [String,nil]
+    attr_reader :proxy_user
+
+    # @return [String,nil]
+    attr_reader :proxy_password
+
+    # @return [Numeric,nil]
+    attr_accessor :read_timeout
+
+    # @return [Boolean] Returns true if this connection requires SSL.
+    def ssl?
+      @ssl
+    end
+
+    # @return [Boolean] Returns true if ssl connections should verify the
+    #   peer certificate.
+    def ssl_verify_peer?
+      @ssl_verify_peer
+    end
+
+    # @return [Boolean] Returns true if this connection proxies requests.
+    def proxy?
+      !!proxy_address
+    end
+
+    def request *args, &block
+      pool.request(self, *args, &block)
+    end
+
+    # @return [String] Returns a key that can be used to group connections
+    #   that connection to the same host.
+    def key
+      @key ||= begin
+        %w(
+          host port 
+          ssl ssl_verify_peer ssl_ca_file ssl_ca_path
+          proxy_address proxy_port proxy_user proxy_password
+        ).map{|part| send(part).to_s }.join(":")
+      end
+    end
+
+  end
+end

data/lib/net/http/connection_pool/session.rb

@@ -0,0 +1,93 @@
+# Copyright 2011-2012 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'
+
+class Net::HTTP::ConnectionPool
+
+  # @private
+  class Session
+
+    def initialize http_session, key
+      @http_session = http_session
+      @key = key
+      @created_at = Time.now
+      @last_used_at = nil
+    end
+
+    attr_reader :http_session
+
+    attr_reader :key
+
+    attr_reader :created_at
+
+    attr_reader :last_used_at
+
+    def request *args, &block
+      response = http_session.request(*args, &block)
+      @last_used_at = Time.now
+      response
+    end
+
+    # @return [nil]
+    def finish
+      begin
+        http_session.finish if http_session.started?
+      rescue IOError
+      end
+      nil
+    end
+
+    class << self
+
+      def for connection, open_timeout
+
+        http_args = []
+        http_args << connection.host
+        http_args << connection.port
+        if connection.proxy?
+          http_args << connection.proxy_address
+          http_args << connection.proxy_port
+          http_args << connection.proxy_user
+          http_args << connection.proxy_password
+        end
+
+        http = Net::HTTP.new(*http_args)
+        #http.set_debug_output($stdout)
+        http.open_timeout = open_timeout
+
+        if connection.ssl?
+          http.use_ssl = true
+          if connection.ssl_verify_peer?
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+            http.ca_file = connection.ssl_ca_file if connection.ssl_ca_file
+            http.ca_path = connection.ssl_ca_path if connection.ssl_ca_path
+          else
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+        else
+          http.use_ssl = false
+        end
+
+        http.start
+
+        Session.new(http, connection.key)
+
+      end
+
+    end
+
+  end
+end