aws-sdk 1.2.3 → 1.2.4

data/lib/aws/s3/prefix_and_delimiter_collection.rb

@@ -19,13 +19,6 @@ module AWS
 
       include PrefixedCollection
 
-      def each(options = {}, &block)
-        each_page(options) do |page|
-          each_member_in_page(page, &block)
-        end
-        nil
-      end
-
       # @see Bucket#as_tree
       def as_tree options = {}
         Tree.new(self, { :prefix => prefix }.merge(options))

data/lib/aws/s3/presigned_post.rb

@@ -340,15 +340,21 @@ module AWS
       #   long as they are described by a policy condition (see
       #   {#where}).
       def fields
-        signature =
-          config.signer.sign(policy, "sha1")
 
-        {
+        signature = config.signer.sign(policy, "sha1")
+
+        fields = {
           "AWSAccessKeyId" => config.signer.access_key_id,
           "key" => key,
           "policy" => policy,
           "signature" => signature
         }.merge(optional_fields)
+
+        fields["x-amz-security-token"] = config.signer.session_token if
+          config.signer.session_token
+
+        fields.merge(optional_fields)
+
       end
 
       # @private
@@ -482,14 +488,23 @@ module AWS
       # @private
       private
       def generate_conditions
-        conditions.inject([]) do |ary, (field, field_conds)|
-          ary += field_conds
-        end +
-          [{ "bucket" => bucket.name }] +
-          key_conditions +
-          optional_fields.map { |(n, v)| Hash[[[n, v]]] } +
-          range_conditions +
-          ignored_conditions
+
+        conditions = self.conditions.inject([]) do |list, (field, field_conds)|
+          list + field_conds
+        end 
+        
+        conditions << { "bucket" => bucket.name }
+        conditions += key_conditions
+        conditions += optional_fields.map { |(n, v)| Hash[[[n, v]]] }
+        conditions += range_conditions
+        conditions += ignored_conditions
+        
+        if config.signer.session_token
+          conditions << {"x-amz-security-token" => config.signer.session_token}
+        end
+
+        conditions
+
       end
 
       # @private

data/lib/aws/s3/request.rb

@@ -184,7 +184,7 @@ module AWS
         def sub_resources
           %w(acl location logging notification partNumber policy 
              requestPayment torrent uploadId uploads versionId 
-             versioning versions)
+             versioning versions delete)
         end
 
         def query_parameters

data/lib/aws/s3/s3_object.rb

@@ -410,13 +410,12 @@ module AWS
         upload = multipart_uploads.create(options)
 
         if block_given?
-          result = nil
           begin
             yield(upload)
-          ensure
-            result = upload.close
+            upload.close
+          rescue
+            upload.abort
           end
-          result
         else
           upload
         end
@@ -488,6 +487,10 @@ module AWS
       #   option in the current configuration; for more information,
       #   see {AWS.config}.
       #
+      # @option options :cache_control [String] Can be used to specify
+      #   caching behavior.  See
+      #   http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9
+      #
       # @return [nil]
       def copy_from source, options = {}
 
@@ -524,6 +527,8 @@ module AWS
         copy_opts[:server_side_encryption] =
           options[:server_side_encryption] if
           options.key?(:server_side_encryption)
+        copy_opts[:cache_control] = options[:cache_control] if 
+          options[:cache_control]
         add_configured_write_options(copy_opts)
 
         if options[:reduced_redundancy]
@@ -641,6 +646,7 @@ module AWS
       #   the object ETag matches the provided value.
       #
       # @option options [Range] :range A byte range to read data from
+      #
       def read(options = {}, &blk)
         options[:bucket_name] = bucket.name
         options[:key] = key

data/lib/aws/s3/uploaded_part_collection.rb

@@ -74,7 +74,9 @@ module AWS
 
       # @private
       protected
-      def pagination_markers; [:part_number_marker]; end
+      def pagination_markers
+        [:part_number_marker]
+      end
 
     end
 

data/lib/net/http/connection_pool.rb

@@ -0,0 +1,193 @@
+# 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/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 
+  ]
+
+  # @params [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)
+      session.http_session.read_timeout = connection.read_timeout
+      response = session.request(*request_args, &block)
+    rescue *SOCKET_ERRORS => error
+      # retry socket errors once
+      unless 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 http sessions from the pool that have passed the idle timeout
+  def clean!
+    @pool_mutex.synchronize { _clean }
+  end
+
+  # Finishes 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
+    session = nil
+
+    @pool_mutex.synchronize do
+      _clean
+      session = @pool.find{|idle_session| idle_session.key == connection.key }
+      @pool.delete(session) if session
+    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 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