dynamodb 0.0.2 → 1.1.1

data/lib/dynamodb/success_response.rb

@@ -0,0 +1,51 @@
+module DynamoDB
+  # Successful response from Dynamo
+  class SuccessResponse
+    attr_reader :http_response
+
+    def initialize(http_response)
+      @http_response = http_response
+    end
+
+    def hash_key_element
+      DynamoDB.deserialize(data["LastEvaluatedKey"]["HashKeyElement"])
+    end
+
+    def range_key_element
+      DynamoDB.deserialize(data["LastEvaluatedKey"]["RangeKeyElement"])
+    end
+
+    # Return single item response as a Hash
+    #
+    # Some DynamoDB operations, such as `GetItem`, will only return a
+    # single 'Item' entry. This converts that entry in a Hash where
+    # values have been type-casted into their Ruby equivalents.
+    def item
+      return unless data["Item"]
+      @item ||= DynamoDB.deserialize(data["Item"])
+    end
+
+    # Return an Array of item responses
+    #
+    # DynamoDB operations like `Query` return a collection of entries
+    # under the 'Items' key. This returns an Array of Hashes where
+    # values have been casted to their Ruby equivalents.
+    def items
+      return unless data["Items"]
+      @items ||= data["Items"].map { |i| DynamoDB.deserialize(i) }
+    end
+
+    def success?
+      true
+    end
+
+    def body
+      http_response.body
+    end
+
+    # Access the deserialized JSON response body
+    def data
+      @data ||= MultiJson.load(http_response.body)
+    end
+  end
+end

data/lib/dynamodb/version.rb

@@ -0,0 +1,3 @@
+module DynamoDB
+  VERSION = "1.1.1"
+end

data/lib/net/http/connection_pool.rb

@@ -0,0 +1,226 @@
+# 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'
+require 'logger'
+
+# A wrapper around Net::HTTP that provides a manged pool of persistant HTTP
+# connections.
+#
+#   pool = Net::HTTP::ConnectionPool.new
+#   connection = pool.connection_for('domain.com')
+#   connection.request(Net::HTTP::Get.new('/')) do |resp|
+#     # Connection#request yields Net::HTTPResponse objects
+#     puts resp.body
+#   end
+#
+# @private
+class Net::HTTP::ConnectionPool
+
+  # @param [Hash] options
+  #
+  # @option options [Numeric] :http_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] :http_open_timeout (15) The number of seconds to
+  #   wait when opening a http session before raising a timeout exception.
+  #
+  # @option options [Boolean] :http_wire_trace (false) When +true+, HTTP
+  #   debug output will be sent to the +:logger+.
+  #
+  # @option options [Logger] :logger (Logger.new($stdout)) Where debug out
+  #   is sent (wire traces).
+  #
+  def initialize options = {}
+    @pool_mutex = Mutex.new
+    @pool = []
+    @open_timeout = options[:http_open_timeout] || 15
+    @idle_timeout = options[:http_idle_timeout] || 60
+    @http_wire_trace = !!options[:http_wire_trace]
+    if logger = options[:logger]
+      @logger = logger
+    elsif http_wire_trace?
+      @logger = Logger.new($stdout)
+    end
+  end
+
+  # @return [Integer]
+  attr_reader :idle_timeout
+
+  # @return [Integer]
+  attr_accessor :open_timeout
+
+  # @return [Boolean] Returns +true+ when HTTP debug output (wire traces)
+  #   will be logged.
+  attr_reader :http_wire_trace
+
+  alias_method :http_wire_trace?, :http_wire_trace
+  alias_method :log_wire_trace?, :http_wire_trace
+  alias_method :log_wire_trace, :http_wire_trace
+
+  # @return [Logger] Where debug output is sent.
+  attr_reader :logger
+
+  # Requests a connection object from the connection pool.
+  #
+  #   connection = pool.connection_for('domain.com')
+  #   connection.request(Net::HTTP::Get.new('/index.html')) {|resp|}
+  #   connection.request(Net::HTTP::Get.new('/about.html')) {|resp|}
+  #
+  #   # same thing in block form
+  #   pool.connection_for('domain.com') do |connection|
+  #     connection.request(Net::HTTP::Get.new('/index.html')) {|resp|}
+  #     connection.request(Net::HTTP::Get.new('/about.html')) {|resp|}
+  #   end
+  #
+  # Because the pool manages HTTP sessions you do not have to
+  # worry about closing a connection or returning a connection
+  # 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 should 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 object to use as a proxy.  You should not provide
+  #   +:proxy_uri+ with any 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
+  #
+  # @yield [connection]
+  #
+  # @yieldparam [optional,Connection] connection
+  #
+  # @return [Connection]
+  #
+  def connection_for host, options = {}, &block
+    connection = Connection.new(self, host, options)
+    yield(connection) if block_given?
+    connection
+  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
+
+  # Makes a single HTTP request.  See {Connection#request} for more information
+  # on making an HTTP request.
+  # @return [nil]
+  # @private
+  def request connection, *args, &block
+    session_for(connection) do |session|
+      session.read_timeout = connection.read_timeout
+      session.request(*args, &block)
+    end
+  end
+
+  protected
+
+  # Yields an open http session for the given connection.
+  def session_for connection, &block
+
+    session = nil
+
+    # search the pool for an idle session that can be used
+    @pool_mutex.synchronize do
+      _clean # removes stale sessions
+      session = @pool.find{|idle_session| idle_session.key == connection.key }
+      @pool.delete(session) if session
+    end
+
+    begin
+      # opens a new HTTP session if no suitable idle session was found
+      session = _create_session(connection) unless session
+      yield(session)
+    rescue Exception => error
+      session.finish if session
+      raise error
+    else
+      # only check the session back into the pool if no errors were raised
+      @pool_mutex.synchronize { @pool << session }
+    end
+
+    nil
+
+  end
+
+  def _create_session connection
+    Session.start(connection,
+      :open_timeout => open_timeout,
+      :debug_logger => log_wire_trace? ? logger : nil)
+  end
+
+  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,189 @@
+# 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
+
+  # Represents a HTTP connection.  Call {#request} on a connection like
+  # you would with a Net::HTTPSession object.
+  #
+  # == Getting a Connection object
+  #
+  # To get a connection object, you start with a connection pool:
+  #
+  #   pool = Net::HTTP::ConnectionPool.new
+  #   connection = pool.connection_for('domain.com')
+  #
+  # {ConnectionPool#connection_for} accepts a number of options to control
+  # the connection settings (SSL, proxy, timeouts, etc).
+  #
+  # == Making Requests
+  #
+  # Given a connection object, you call #request.  {Connection#request}
+  # yields Net::HTTPResponse objects (when given a block).  You should 
+  # read the response (via #body or #read_body) before the end of the
+  # block.
+  #
+  #   connection.request(Net::HTTP::Get.new('/')) do |resp|
+  #     puts resp.body
+  #   end
+  #
+  class Connection
+
+    # Use {ConnectionPool#connection_for} to construct {Connection} objects.
+    # @private
+    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
+
+    # Makes a single HTTP request.  The Net::HTTPResponse is yielded to the
+    # given block.
+    #
+    #   pool = Net::HTTP::ConnectionPool.new
+    #   connection = pool.connection_for('www.google.com')
+    #
+    #   connection.request(Net::HTTP::Get.new('/')) do |response|
+    #     # yeilds a Net::HTTPResponse object
+    #     puts "STATUS CODE: #{response.code}"
+    #     puts "HEADERS: #{response.to_hash.inspect}"
+    #     puts "BODY:\n#{response.body}"
+    #   end
+    #
+    # If you want to read the HTTP response body in chunks (useful for
+    # large responses you do not want to load into memory), you should
+    # pass a block to the #read_body method of the yielded response.
+    #
+    #   File.open('output.txt', 'w') do |file|
+    #     connection.request(Net::HTTP::Get.new('/')) do |response|
+    #       response.read_body do |chunk|
+    #         file.write(chunk)
+    #       end
+    #     end
+    #   end
+    #
+    # If you omit the block when calling #request, you will not be able
+    # to read the response.  This method never returns the 
+    # Net::HTTPResponse generated.
+    #
+    # This method passes *args to Net::HTTPSession#request.  See the
+    # Ruby standard lib documentation for more documentation about 
+    # accepted arguments.
+    #
+    # @note You should read the yielded response object before the end
+    #  of the passed block. Do no save a reference to yielded response
+    #  objects.
+    #
+    # @yield [response]
+    # @yieldparam [Net::HTTPResponse] response
+    # @return [nil]
+    def request *args, &block
+      pool.request(self, *args, &block)
+    end
+
+    # @return [String] Returns a key that can be used to group connections
+    #   that may share the same HTTP sessions.
+    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