aws-s3 0.3.0 → 0.4.0

data/README

@@ -329,7 +329,7 @@ and specifying the object's key without a special authenticated url:
 
  http://s3.amazonaws.com/marcel/kiss.jpg
 
-==== Building costum access policies
+==== Building custum access policies
 
 For both buckets and objects, you can use the <tt>acl</tt> method to see its access control policy:
 
@@ -444,6 +444,15 @@ If you have an object handy, you can use its <tt>url</tt> method with the same o
 
   song.url(:expires_in => 30)
 
+To get an unauthenticated url for the object, such as in the case
+when the object is publicly readable, pass the
+<tt>:authenticated</tt> option with a value of <tt>false</tt>.
+
+  S3Object.url_for('beluga_baby.jpg',
+                   'marcel',
+                   :authenticated => false)
+  # => http://s3.amazonaws.com/marcel/beluga_baby.jpg
+
 
 == Logging
 ==== Tracking requests made on a bucket

data/Rakefile

@@ -140,7 +140,7 @@ namespace :dist do
     rubyforge.login
 
     version_already_released = lambda do
-      releases = rubyforge.config['rubyforge']['release_ids']
+      releases = rubyforge.userconfig['rubyforge']['release_ids']
       releases.has_key?(spec.name) && releases[spec.name][spec.version]
     end
     

data/lib/aws/s3/acl.rb

@@ -24,7 +24,7 @@ module AWS
     # 
     #  http://s3.amazonaws.com/marcel/kiss.jpg
     # 
-    # ==== Building costum access policies
+    # ==== Building custum access policies
     # 
     # For both buckets and objects, you can use the <tt>acl</tt> method to see its access control policy:
     # 
@@ -445,7 +445,7 @@ module AWS
         end
         
         def inspect #:nodoc:
-          "#<%s:0x%s %s>" [self.class, object_id, type_representation || '(type not set yet)']
+          "#<%s:0x%s %s>" %  [self.class, object_id, type_representation || '(type not set yet)']
         end
         
         private
@@ -633,4 +633,4 @@ module AWS
       end
     end
   end
-end
+end

data/lib/aws/s3/base.rb

@@ -66,7 +66,7 @@ module AWS #:nodoc:
         def request(verb, path, options = {}, body = nil, attempts = 0, &block)
           Service.response = nil
           process_options!(options, verb)
-          response = response_class.new(connection.request(verb, path, options, body, &block))
+          response = response_class.new(connection.request(verb, path, options, body, attempts, &block))
           Service.response = response
 
           Error::Response.new(response.response).error.raise if response.error?
@@ -75,7 +75,6 @@ module AWS #:nodoc:
         # errors are few and far between the request method will rescue InternalErrors the first three times they encouter them
         # and will retry the request again. Most of the time the second attempt will work.
         rescue *retry_exceptions
-          body.rewind if body.respond_to?(:rewind)        
           attempts == 3 ? raise : (attempts += 1; retry)
         end
 
@@ -176,7 +175,7 @@ module AWS #:nodoc:
           end
 
           def retry_exceptions
-            [InternalError, Timeout::Error, Errno::EPIPE, Errno::EINVAL, RequestTimeout]
+            [InternalError, RequestTimeout]
           end
           
           class RequestOptions < Hash #:nodoc:

data/lib/aws/s3/connection.rb

@@ -23,7 +23,9 @@ module AWS
         connect
       end
           
-      def request(verb, path, headers = {}, body = nil, &block)
+      def request(verb, path, headers = {}, body = nil, attempts = 0, &block)
+        body.rewind if body.respond_to?(:rewind) unless attempts.zero?      
+        
         requester = Proc.new do 
           path    = self.class.prepare_path(path)
           request = request_method(verb).new(path, headers)
@@ -47,13 +49,21 @@ module AWS
         else
           http.start(&requester)
         end
+      rescue Errno::EPIPE, Timeout::Error, Errno::EPIPE, Errno::EINVAL
+        @http = create_connection
+        attempts == 3 ? raise : (attempts += 1; retry)
       end
       
       def url_for(path, options = {})
+        authenticate = options.delete(:authenticated)
+        # Default to true unless explicitly false
+        authenticate = true if authenticate.nil? 
         path         = self.class.prepare_path(path)
         request      = request_method(:get).new(path, {})
         query_string = query_string_authentication(request, options)
-        "#{protocol(options)}#{http.address}#{path}?#{query_string}"
+        returning "#{protocol(options)}#{http.address}#{port_string}#{path}" do |url|
+          url << "?#{query_string}" if authenticate
+        end
       end
       
       def subdomain
@@ -77,14 +87,31 @@ module AWS
           raise MissingAccessKey.new(missing_keys) unless missing_keys.empty?
         end
         
+        def create_connection
+          http             = http_class.new(options[:server], options[:port])
+          http.use_ssl     = !options[:use_ssl].nil? || options[:port] == 443
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          http
+        end
+        
+        def http_class
+          if options.connecting_through_proxy?
+            Net::HTTP::Proxy(*options.proxy_settings)
+          else
+            Net::HTTP
+          end
+        end
+        
         def connect
           extract_keys!
-          @http             = Net::HTTP.new(options[:server], options[:port])
-          @http.use_ssl     = !options[:use_ssl].nil? || options[:port] == 443
-          @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-          @http
+          @http = create_connection
         end
-        
+
+        def port_string
+          default_port = options[:use_ssl] ? 443 : 80
+          http.port == default_port ? '' : ":#{http.port}"
+        end
+
         def ensure_content_type!(request)
           request['Content-Type'] ||= 'binary/octet-stream'
         end
@@ -152,6 +179,13 @@ module AWS
           # * <tt>:persistent</tt> - Whether to use a persistent connection to the server. Having this on provides around a two fold 
           # performance increase but for long running processes some firewalls may find the long lived connection suspicious and close the connection.
           # If you run into connection errors, try setting <tt>:persistent</tt> to false. Defaults to true.
+          # * <tt>:proxy</tt> - If you need to connect through a proxy, you can specify your proxy settings by specifying a <tt>:host</tt>, <tt>:port</tt>, <tt>:user</tt>, and <tt>:password</tt>
+          # with the <tt>:proxy</tt> option.
+          # The <tt>:host</tt> setting is required if specifying a <tt>:proxy</tt>. 
+          #   
+          #   AWS::S3::Bucket.established_connection!(:proxy => {
+          #     :host => '...', :port => 8080, :user => 'marcel', :password => 'secret'
+          #   })
           def establish_connection!(options = {})
             # After you've already established the default connection, just specify 
             # the difference for subsequent connections
@@ -208,7 +242,7 @@ module AWS
       class Options < Hash #:nodoc:
         class << self
           def valid_options
-            [:access_key_id, :secret_access_key, :server, :port, :use_ssl, :persistent]
+            [:access_key_id, :secret_access_key, :server, :port, :use_ssl, :persistent, :proxy]
           end
         end
         
@@ -217,17 +251,41 @@ module AWS
           super()
           @options = options
           validate!
+          extract_proxy_settings!
           extract_persistent!
           extract_server!
           extract_port!
           extract_remainder!
         end
         
+        def connecting_through_proxy?
+          !self[:proxy].nil?
+        end
+        
+        def proxy_settings
+          proxy_setting_keys.map do |proxy_key| 
+            self[:proxy][proxy_key]
+          end
+        end
+        
         private
+          def proxy_setting_keys
+            [:host, :port, :user, :password]
+          end
+          
+          def missing_proxy_settings?
+            !self[:proxy].keys.include?(:host)
+          end
+          
           def extract_persistent!
             self[:persistent] = options.has_key?(:persitent) ? options[:persitent] : true
           end
           
+          def extract_proxy_settings!
+            self[:proxy] = options.delete(:proxy) if options.include?(:proxy)
+            validate_proxy_settings!
+          end
+          
           def extract_server!
             self[:server] = options.delete(:server) || DEFAULT_HOST
           end
@@ -244,7 +302,13 @@ module AWS
             invalid_options = options.keys.select {|key| !self.class.valid_options.include?(key)}
             raise InvalidConnectionOption.new(invalid_options) unless invalid_options.empty?
           end
+          
+          def validate_proxy_settings!
+            if connecting_through_proxy? && missing_proxy_settings?
+              raise ArgumentError, "Missing proxy settings. Must specify at least :host."
+            end
+          end
       end
     end
   end
-end
+end

data/lib/aws/s3/extensions.rb

@@ -76,7 +76,8 @@ class CoercibleString < String
     case self
     when 'true':          true
     when 'false':         false
-    when  /^\d+$/:        Integer(self)
+    # Don't coerce numbers that start with zero
+    when  /^[1-9]+\d*$/:   Integer(self)
     when datetime_format: Time.parse(self)
     else
       self
@@ -127,6 +128,13 @@ module Kernel
   end
 end
 
+class Object
+  def returning(value)
+    yield(value)
+    value
+  end
+end
+
 class Module
   def memoized(method_name)
     original_method = "unmemoized_#{method_name}_#{Time.now.to_i}"

data/lib/aws/s3/logging.rb

@@ -47,7 +47,7 @@ module AWS
       #
       # See the documentation for Logging::Management::ClassMethods for more information on how to get the logging status of a bucket. 
       class Status
-        include SelectiveAttributeProxy #:nodoc:
+        include SelectiveAttributeProxy
         attr_reader :enabled
         alias_method :logging_enabled?, :enabled
       

data/lib/aws/s3/object.rb

@@ -276,6 +276,15 @@ module AWS
         # If you have an object handy, you can use its <tt>url</tt> method with the same objects:
         #
         #   song.url(:expires_in => 30)
+        #
+        # To get an unauthenticated url for the object, such as in the case
+        # when the object is publicly readable, pass the
+        # <tt>:authenticated</tt> option with a value of <tt>false</tt>.
+        #
+        #   S3Object.url_for('beluga_baby.jpg',
+        #                    'marcel',
+        #                    :authenticated => false)
+        #   # => http://s3.amazonaws.com/marcel/beluga_baby.jpg
         def url_for(name, bucket = nil, options = {})
           connection.url_for(path!(bucket, name, options), options) # Do not normalize options
         end

data/lib/aws/s3/version.rb

@@ -2,11 +2,11 @@ module AWS
   module S3
     module VERSION #:nodoc:
       MAJOR    = '0'
-      MINOR    = '3'
+      MINOR    = '4'
       TINY     = '0' 
       BETA     = nil # Time.now.to_i.to_s
     end
     
     Version = [VERSION::MAJOR, VERSION::MINOR, VERSION::TINY, VERSION::BETA].compact * '.'
   end
-end
+end

data/support/faster-xml-simple/lib/faster_xml_simple.rb

@@ -22,34 +22,61 @@ require 'rubygems'
 require 'xml/libxml'
 
 class FasterXmlSimple
+  Version = '0.5.0'
   class << self
+    # Take an string containing XML, and returns a hash representing that 
+    # XML document.  For example:
+    # 
+    #   FasterXmlSimple.xml_in("<root><something>1</something></root>")
+    #   {"root"=>{"something"=>{"__content__"=>"1"}}}
+    #
+    # Faster XML Simple is designed to be a drop in replacement for the xml_in
+    # functionality of http://xml-simple.rubyforge.org
+    #
+    # The following options are supported:
+    # 
+    # * <tt>contentkey</tt>: The key to use for the content of text elements,
+    #   defaults to '\_\_content__'
+    # * <tt>forcearray</tt>: The list of elements which should always be returned
+    #   as arrays.  Under normal circumstances single element arrays are inlined.
+    # * <tt>suppressempty</tt>: The value to return for empty elements, pass +true+
+    #   to remove empty elements entirely.
+    # * <tt>keeproot</tt>:  By default the hash returned has a single key with the
+    #   name of the root element.  If the name of the root element isn't 
+    #   interesting to you, pass +false+. 
+    # * <tt>forcecontent</tt>:  By default a text element with no attributes, will 
+    #   be collapsed to just a string instead of a hash with a single key.  
+    #   Pass +true+ to prevent this.
+    #
+    #
     def xml_in(string, options={})
       new(string, options).out
     end
   end
   
-  attr_reader :doc, :options, :current_element
-  
-  def initialize(string, options)
-    @doc             = parse(string)
-    @options         = default_options.merge options
-    @current_element = nil
+  def initialize(string, options) #:nodoc:
+    @doc     = parse(string)
+    @options = default_options.merge options
   end
   
-  def out
-    {doc.root.name => collapse(doc.root)}
+  def out #:nodoc:
+    if @options['keeproot']
+      {@doc.root.name => collapse(@doc.root)}
+    else
+      collapse(@doc.root)
+    end
   end
   
   private
     def default_options
-      {'contentkey' => '__content__', 'forcearray' => []}
+      {'contentkey' => '__content__', 'forcearray' => [], 'keeproot'=>true}
     end
   
     def collapse(element)
       result = hash_of_attributes(element) 
       if text_node? element
         text = collapse_text(element)
-        result.merge!(content_key => text) if text =~ /\S/
+        result[content_key] = text if text =~ /\S/
       elsif element.children?
         element.inject(result) do |hash, child|
           unless child.text?
@@ -64,26 +91,24 @@ class FasterXmlSimple
       end
       # Compact them to ensure it complies with the user's requests
       inline_single_element_arrays(result) 
-      suppress_empty_content(result) unless force_content?
       remove_empty_elements(result) if suppress_empty?
-      
-      result
-    end
-  
-    def empty_element
-      if !options.has_key? 'suppressempty'
-        {}
+      if content_only?(result) && !force_content?
+        result[content_key]
       else
-        options['suppressempty']
+        result
       end
     end
+    
+    def content_only?(result)
+      result.keys == [content_key]
+    end
   
     def content_key
-      options['contentkey']
+      @options['contentkey']
     end
   
     def force_array?(key_name)
-      Array(options['forcearray']).include?(key_name)
+      Array(@options['forcearray']).include?(key_name)
     end
   
     def inline_single_element_arrays(result)
@@ -103,21 +128,31 @@ class FasterXmlSimple
     end
     
     def suppress_empty?
-      options['suppressempty'] == true
+      @options['suppressempty'] == true
+    end
+     
+    def empty_element
+      if !@options.has_key? 'suppressempty'
+        {}
+      else
+        @options['suppressempty']
+      end
     end
 
-
-
+    # removes the content if it's nothing but blanks,  prevents
+    # the hash being polluted with lots of content like "\n\t\t\t" 
     def suppress_empty_content(result)
       result.delete content_key if result[content_key] !~ /\S/ 
     end
   
     def force_content?
-      options['forcecontent']
+      @options['forcecontent']
     end
   
     # a text node is one with 1 or more child nodes which are
-    # text nodes, and no non-text children
+    # text nodes, and no non-text children, there's no sensible
+    # way to support nodes which are text and markup like:
+    # <p>Something <b>Bold</b> </p>
     def text_node?(element)
       !element.text? && element.all? {|c| c.text?}
     end
@@ -145,7 +180,7 @@ class FasterXmlSimple
     end
 end
 
-class XmlSimple
+class XmlSimple # :nodoc:
   def self.xml_in(*args)
     FasterXmlSimple.xml_in *args
   end

data/support/faster-xml-simple/test/regression_test.rb

@@ -33,4 +33,15 @@ class RegressionTest < FasterXSTest
     end
   end
   
+  def test_keeproot_false
+    str = "<asdf><fdsa>1</fdsa></asdf>"
+    expected = {"fdsa"=>"1"}
+    assert_equal expected, FasterXmlSimple.xml_in(str, 'keeproot'=>false)
+  end
+  
+  def test_keeproot_false_with_force_content
+    str = "<asdf><fdsa>1</fdsa></asdf>"
+    expected = {"fdsa"=>{"__content__"=>"1"}}
+    assert_equal expected, FasterXmlSimple.xml_in(str, 'keeproot'=>false, 'forcecontent'=>true)
+  end
 end

data/test/connection_test.rb

@@ -74,6 +74,35 @@ class ConnectionTest < Test::Unit::TestCase
       assert_equal klass, c.send(:request_method, verb)
     end
   end
+
+  def test_url_for_uses_default_protocol_server_and_port
+    connection = Connection.new(:access_key_id => '123', :secret_access_key => 'abc', :port => 80)
+    assert_match %r(^http://s3\.amazonaws\.com/foo\?), connection.url_for('/foo')
+
+    connection = Connection.new(:access_key_id => '123', :secret_access_key => 'abc', :use_ssl => true, :port => 443)
+    assert_match %r(^https://s3\.amazonaws\.com/foo\?), connection.url_for('/foo')
+  end
+
+  def test_url_for_remembers_custom_protocol_server_and_port
+    connection = Connection.new(:access_key_id => '123', :secret_access_key => 'abc', :server => 'example.org', :port => 555, :use_ssl => true)
+    assert_match %r(^https://example\.org:555/foo\?), connection.url_for('/foo')
+  end
+
+  def test_url_for_with_and_without_authenticated_urls
+    connection = Connection.new(:access_key_id => '123', :secret_access_key => 'abc', :server => 'example.org')
+    authenticated = lambda {|url| url['?AWSAccessKeyId']}
+    assert authenticated[connection.url_for('/foo')]
+    assert authenticated[connection.url_for('/foo', :authenticated => true)]
+    assert !authenticated[connection.url_for('/foo', :authenticated => false)]
+  end
+  
+  def test_connecting_through_a_proxy
+    connection = nil
+    assert_nothing_raised do
+      connection = Connection.new(@keys.merge(:proxy => sample_proxy_settings))
+    end
+    assert connection.http.proxy?
+  end
 end
 
 class ConnectionOptionsTest < Test::Unit::TestCase
@@ -115,8 +144,41 @@ class ConnectionOptionsTest < Test::Unit::TestCase
     end
   end
   
-  private
+  def test_not_specifying_all_required_proxy_settings_raises
+    assert_raises(ArgumentError) do
+      generate_options(:proxy => {})
+    end
+  end
+  
+  def test_not_specifying_proxy_option_at_all_does_not_raise
+    assert_nothing_raised do
+      generate_options
+    end
+  end
+  
+  def test_specifying_all_required_proxy_settings
+    assert_nothing_raised do
+      generate_options(:proxy => sample_proxy_settings)
+    end
+  end
+  
+  def test_only_host_setting_is_required
+    assert_nothing_raised do
+      generate_options(:proxy => {:host => 'http://google.com'})
+    end
+  end
+  
+  def test_proxy_settings_are_extracted
+    options = generate_options(:proxy => sample_proxy_settings)
+    assert_equal sample_proxy_settings.values.map {|value| value.to_s}.sort, options.proxy_settings.map {|value| value.to_s}.sort
+  end
   
+  def test_recognizing_that_the_settings_want_to_connect_through_a_proxy
+    options = generate_options(:proxy => sample_proxy_settings)
+    assert options.connecting_through_proxy?
+  end
+  
+  private
     def assert_key_transfered(key, value, options)
       assert_equal value, options[key]
       assert !options.instance_variable_get('@options').has_key?(key)
@@ -125,4 +187,4 @@ class ConnectionOptionsTest < Test::Unit::TestCase
     def generate_options(options = {})
       Connection::Options.new(options)
     end
-end
+end

data/test/extensions_test.rb

@@ -86,7 +86,8 @@ class CoercibleStringTest < Test::Unit::TestCase
       ['2006-10-29T23:14:47.000Z', Time.parse('2006-10-29T23:14:47.000Z')],
       ['Hello!', 'Hello!'],
       ['false23', 'false23'],
-      ['03 1-2-3-Apple-Tree.mp3', '03 1-2-3-Apple-Tree.mp3']
+      ['03 1-2-3-Apple-Tree.mp3', '03 1-2-3-Apple-Tree.mp3'],
+      ['0815', '0815'] # This number isn't coerced because the leading zero would be lost
     ]
     
     coercions.each do |before, after|

data/test/test_helper.rb

@@ -79,4 +79,8 @@ end
 
 class Test::Unit::TestCase
   include AWS::S3
+  
+  def sample_proxy_settings
+    {:host => 'http://google.com', :port => 8080, :user => 'marcel', :password => 'secret'}
+  end
 end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
+rubygems_version: 0.9.4
 specification_version: 1
 name: aws-s3
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
-date: 2006-12-21 00:00:00 -06:00
+  version: 0.4.0
+date: 2007-07-08 00:00:00 -05:00
 summary: Client library for Amazon's Simple Storage Service's REST API
 require_paths: 
 - lib