right_aws 1.3.0 → 1.4.2

data/History.txt

@@ -1,66 +1,68 @@
-== 1.1.0 / 2007-08-10
+== 1.1.0 2007-08-10
 Initial release.
 
-== 1.2.0 / 2007-09-12
-------------------------------------------------------------------------
-r1718 | todd | 2007-09-12 15:34:37 -0700 (Wed, 12 Sep 2007) | 3 lines
+== 1.2.0 2007-09-12
 
-(#458) Extensive documentation review, rework, and expansion.  Also added
-coverage analysis to the test suite using RCov.
+* r1718, todd, 2007-09-12 15:34:37
+  * # 458, Extensive documentation review, rework, and expansion.  Also added 
+    coverage analysis to the test suite using RCov.
 
-------------------------------------------------------------------------
-r1690 | todd | 2007-09-07 15:23:11 -0700 (Fri, 07 Sep 2007) | 2 lines
+* r1690, todd, 2007-09-07 15:23:11
+  * # 447, Add support.rb to manifest
 
-(#447) Add support.rb to manifest
+* r1688, todd, 2007-09-07 13:57:39
+  * # 447, Use Active Support if available, but don't require it.  Load our own
+    extensions if it's not present.  This keeps us from overloading ActiveSupport if
+    a user's already using it.
 
-------------------------------------------------------------------------
-r1688 | todd | 2007-09-07 13:57:39 -0700 (Fri, 07 Sep 2007) | 4 lines
+* r1687, todd, 2007-09-07 11:36:43
+  * # 447, Removed dependency on activesupport
 
-#(447)  Use Active Support if available, but don't require it.  Load our own
-extensions if it's not present.  This keeps us from overloading ActiveSupport if
-a user's already using it.
+* r1676, konstantin, 2007-09-06 01:27:09
+  * paid AMIs, small fix
 
-------------------------------------------------------------------------
-r1687 | todd | 2007-09-07 11:36:43 -0700 (Fri, 07 Sep 2007) | 2 lines
+* r1667, konstantin, 2007-09-05 12:58:10
+  * # 427, paid AMI support for ec2_instances
 
-(#447) Removed dependency on activesupport
+* r1658, konstantin, 2007-09-05 01:02:25
+  * params improvements for ec2.describe_xxx, now ones can use a String as well as an Array.
 
-------------------------------------------------------------------------
-r1676 | konstantin | 2007-09-06 01:27:09 -0700 (Thu, 06 Sep 2007) | 1 line
+* r1653, konstantin, 2007-09-04 12:31:19
+  * libxml and paid AMI support added
 
-paid AMIs, small fix
-------------------------------------------------------------------------
-r1667 | konstantin | 2007-09-05 12:58:10 -0700 (Wed, 05 Sep 2007) | 1 line
+* r1581, tve, 2007-08-24 16:21:45
+  * Improved RightAws documentation
 
-#427, Gems,  paid AMI support for ec2_instances
-------------------------------------------------------------------------
-r1658 | konstantin | 2007-09-05 01:02:25 -0700 (Wed, 05 Sep 2007) | 1 line
+== 1.3.0 2007-09-26
 
-RightGems: a couple of params improvements, now ones can use a String as well as an Array.
-------------------------------------------------------------------------
-r1653 | konstantin | 2007-09-04 12:31:19 -0700 (Tue, 04 Sep 2007) | 1 line
+* r1754, todd, 2007-09-19 13:48:34
+  * # 487, # 488, Consolidate a lot of code that was repeated in three places.
+    Fix error handling path when using streaming GET interfaces with S3.
+    Also add a stub for RightHttpConnection which allows more control over the
+    unit tests.  Expand the unit tests and coverage tests. 
 
-Right gems: libxml and paid AMI support added
-------------------------------------------------------------------------
-r1581 | tve | 2007-08-24 16:21:45 -0700 (Fri, 24 Aug 2007) | 1 line
+* r1755, todd, 2007-09-19 14:29:19
+  * # 487, RDoc fixes after code consolidation
 
-Improved RightAws documentation
-------------------------------------------------------------------------
+* r1866, konstantin, 2007-10-05 06:17:36
+  * # 220, close connection on HTTP 5xx/4xx errors
 
-== 1.3.0 / 2007-09-26
-------------------------------------------------------------------------
-r1754 | todd | 2007-09-19 13:48:34 -0700 (Wed, 19 Sep 2007) | 6 lines
+== 1.4.0 2007-10-10
 
-(#487, #488) Consolidate a lot of code that was repeated in three places.
-Fix error handling path when using streaming GET interfaces with S3.
-Also add a stub for RightHttpConnection which
-allows more control over the unit tests.  Expand the unit tests and coverage
-tests. 
-------------------------------------------------------------------------
-r1755 | todd | 2007-09-19 14:29:19 -0700 (Wed, 19 Sep 2007) | 2 lines
+* r1868, konstantin, 2007-10-05 06:38:37
+  * # 220, inst_type branch merge into 1.3.0 release
 
-(#487) RDoc fixes after code consolidation
+* r1869, konstantin, 2007-10-05 07:32:34
+  * right_http_connection 1.1.1 requirements fixed
 
-------------------------------------------------------------------------
+* r1879, konstantin, 2007-10-07 02:11:24
+  * # 524, blocks added to ec2_describe_xxx to support aws_cache
 
+* r1924, konstantin, 2007-10-12 11:35:06
+  * # 536, user_data bug fix 
 
+* r1929, tve,  2007-10-15 00:00:11
+  * Fix libxml/rexml selection bug
+
+* r1938, konstantin, 2007-10-16 10:53:56
+  * instance type support is set to default 

data/Rakefile

@@ -18,7 +18,7 @@ Hoe.new('right_aws', RightAws::VERSION::STRING) do |p|
   p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
   p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
   p.remote_rdoc_dir = "/right_aws_gem_doc"
-  p.extra_deps = [['right_http_connection','>= 0.1.4']]
+  p.extra_deps = [['right_http_connection','>= 1.2.0']]
   p.test_globs = testglobs 
 end
 

data/lib/awsbase/right_awsbase.rb

@@ -89,6 +89,8 @@ module RightAws
     attr_accessor :logger
       # Initial params hash
     attr_accessor :params
+      # RightHttpConnection instance
+    attr_reader :connection
 
     def init(service_info, aws_access_key_id, aws_secret_access_key, params={}) #:nodoc:
       @params = params
@@ -117,6 +119,7 @@ module RightAws
     end
 
     def request_info_impl(connection, benchblock, request, parser, &block) #:nodoc:
+      @connection    = connection
       @last_request  = request[:request]
       @last_response = nil
       response=nil
@@ -131,7 +134,7 @@ module RightAws
         # Exceptions can originate from code directly in the block, or from user
         # code called in the other block which is passed to response.read_body.
         benchblock.service.add! do
-          responsehdr = connection.request(request) do |response|
+          responsehdr = @connection.request(request) do |response|
           #########
             begin
               @last_response = response
@@ -139,7 +142,7 @@ module RightAws
                 @error_handler = nil
                 response.read_body(&block)
               else
-                @error_handler = AWSErrorHandler.new(self, parser, self.class.amazon_problems) unless @error_handler
+                @error_handler = AWSErrorHandler.new(self, parser, :errors_list => self.class.amazon_problems) unless @error_handler
                 check_result   = @error_handler.check(request)
                 if check_result
                   @error_handler = nil
@@ -163,7 +166,7 @@ module RightAws
           return parser.result
         end
       else
-        benchblock.service.add!{ response = connection.request(request) }
+        benchblock.service.add!{ response = @connection.request(request) }
           # check response for errors...
         @last_response = response
         if response.is_a?(Net::HTTPSuccess)
@@ -171,7 +174,7 @@ module RightAws
           benchblock.xml.add! { parser.parse(response) }
           return parser.result
         else
-          @error_handler = AWSErrorHandler.new(self, parser, self.class.amazon_problems) unless @error_handler
+          @error_handler = AWSErrorHandler.new(self, parser, :errors_list => self.class.amazon_problems) unless @error_handler
           check_result   = @error_handler.check(request)
           if check_result
             @error_handler = nil
@@ -256,6 +259,8 @@ module RightAws
 
 
   class AWSErrorHandler
+    # 0-100 (%) 
+    DEFAULT_CLOSE_ON_4XX_PROBABILITY = 10     
     
     @@reiteration_start_delay = 0.2
     def self.reiteration_start_delay
@@ -273,20 +278,45 @@ module RightAws
       @@reiteration_time = reiteration_time
     end
     
-    def initialize(aws, parser,  errors_list=nil,  reiteration_time=nil) #:nodoc:
+    @@close_on_error = true 
+    def self.close_on_error 
+      @@close_on_error 
+    end 
+    def self.close_on_error=(close_on_error) 
+      @@close_on_error = close_on_error 
+    end 
+ 
+    @@close_on_4xx_probability = DEFAULT_CLOSE_ON_4XX_PROBABILITY 
+    def self.close_on_4xx_probability 
+      @@close_on_4xx_probability 
+    end 
+    def self.close_on_4xx_probability=(close_on_4xx_probability) 
+      @@close_on_4xx_probability = close_on_4xx_probability 
+    end 
+ 
+    # params: 
+    #  :reiteration_time 
+    #  :errors_list 
+    #  :close_on_error           = true | false 
+    #  :close_on_4xx_probability = 1-100 
+    def initialize(aws, parser, params={}) #:nodoc:     
       @aws           = aws              # Link to RightEc2 | RightSqs | RightS3 instance
       @parser        = parser           # parser to parse Amazon response
       @started_at    = Time.now
-      @stop_at       = @started_at  + (reiteration_time || @@reiteration_time)
-      @errors_list   = errors_list || []
+      @stop_at       = @started_at  + (params[:reiteration_time] || @@reiteration_time) 
+      @errors_list   = params[:errors_list] || [] 
       @reiteration_delay = @@reiteration_start_delay
       @retries       = 0
+      # close current HTTP(S) connection on 5xx, errors from list and 4xx errors 
+      @close_on_error           = params[:close_on_error].nil? ? @@close_on_error : params[:close_on_error] 
+      @close_on_4xx_probability = params[:close_on_4xx_probability] || @@close_on_4xx_probability       
     end
     
       # Returns false if 
     def check(request)  #:nodoc:
       result           = false
       error_found      = false
+      error_match      = nil
       last_errors_text = ''
       response         = @aws.last_response
         # log error
@@ -311,12 +341,20 @@ module RightAws
       @errors_list.each do |error_to_find|
         if last_errors_text[/#{error_to_find}/i]
           error_found = true
+          error_match = error_to_find
           @aws.logger.warn("##### Retry is needed, error pattern match: #{error_to_find} #####")
           break
         end
       end
         # check the time has gone from the first error come
       if error_found
+        # Close the connection to the server and recreate a new one. 
+        # It may have a chance that one server is a semi-down and reconnection 
+        # will help us to connect to the other server 
+        if @close_on_error 
+          @aws.connection.finish "#{self.class.name}: error match to pattern '#{error_match}'" 
+        end 
+                 
         if (Time.now < @stop_at)
           @retries += 1
           @aws.logger.warn("##### Retry ##{@retries} is being performed. Sleeping for #{@reiteration_delay} sec. Whole time: #{Time.now-@started_at} sec ####")
@@ -326,6 +364,16 @@ module RightAws
           result = @aws.request_info(request, @parser)
         else
           @aws.logger.warn("##### Ooops, time is over... ####")
+        end 
+      # aha, this is unhandled error: 
+      elsif @close_on_error 
+        # Is this a 5xx error ? 
+        if @aws.last_response.code.to_s[/^5\d\d$/] 
+          @aws.connection.finish "#{self.class.name}: code: #{@aws.last_response.code}: '#{@aws.last_response.message}'" 
+        # Is this a 4xxx error ? 
+        elsif @aws.last_response.code.to_s[/^4\d\d$/] && @close_on_4xx_probability > rand(100) 
+          @aws.connection.finish "#{self.class.name}: code: #{@aws.last_response.code}: '#{@aws.last_response.message}', " + 
+                                 "probability: #{@close_on_4xx_probability}%"           
         end
       end
       result
@@ -336,8 +384,36 @@ module RightAws
 
   #-----------------------------------------------------------------
 
+  class RightSaxParserCallback #:nodoc:
+    def self.include_callback 
+      include XML::SaxParser::Callbacks       
+    end 
+    def initialize(right_aws_parser) 
+      @right_aws_parser = right_aws_parser 
+    end 
+    def on_start_element(name, attr_hash) 
+      @right_aws_parser.tag_start(name, attr_hash) 
+    end   
+    def on_characters(chars) 
+      @right_aws_parser.text(chars) 
+    end 
+    def on_end_element(name) 
+      @right_aws_parser.tag_end(name) 
+    end 
+    def on_start_document; end 
+    def on_comment(msg); end 
+    def on_processing_instruction(target, data); end 
+    def on_cdata_block(cdata); end 
+    def on_end_document; end 
+  end 
+ 
   class RightAWSParser  #:nodoc:
-    @@xml_lib = 'rexml' # xml library name: 'rexml' | 'libxml'
+      # default parsing library 
+    DEFAULT_XML_LIBRARY = 'rexml' 
+      # a list of supported parsers 
+    @@supported_xml_libs = [DEFAULT_XML_LIBRARY, 'libxml'] 
+     
+    @@xml_lib = DEFAULT_XML_LIBRARY # xml library name: 'rexml' | 'libxml' 
     def self.xml_lib
       @@xml_lib
     end
@@ -379,32 +455,41 @@ module RightAws
         # Get response body
       xml_text = xml_text.body unless xml_text.is_a?(String)
       @xml_lib = params[:xml_lib] || @xml_lib
+        # check that we had no problems with this library otherwise use default 
+      @xml_lib = DEFAULT_XML_LIBRARY unless @@supported_xml_libs.include?(@xml_lib)       
         # load xml library
       if @xml_lib=='libxml' && !defined?(XML::SaxParser)
         begin
-          require 'xml/libxml' 
+          require 'xml/libxml'
+          # is it new ? - Setup SaxParserCallback 
+          if XML::Parser::VERSION >= '0.5.1.0'
+            RightSaxParserCallback.include_callback 
+          end           
         rescue LoadError => e
-          @xml_lib = 'rexml'
+          @@supported_xml_libs.delete(@xml_lib) 
+          @xml_lib = DEFAULT_XML_LIBRARY           
           if @logger
             @logger.error e.inspect
             @logger.error e.backtrace
-            @logger.info "Can not load 'libxml' library. 'Rexml' is used for parsing."
+            @logger.info "Can not load 'libxml' library. '#{DEFAULT_XML_LIBRARY}' is used for parsing." 
           end
         end
       end
         # Parse the xml text
       case @xml_lib
       when 'libxml'  
-        xml = XML::SaxParser.new
-        xml.string = xml_text
-        xml.on_start_element{|name, attr_hash| self.tag_start(name, attr_hash)}
-        xml.on_characters{   |text|            self.text(text)}
-        xml.on_end_element{  |name|            self.tag_end(name)}
+        xml        = XML::SaxParser.new 
+        xml.string = xml_text 
+        # check libxml-ruby version 
+        if XML::Parser::VERSION >= '0.5.1.0'
+          xml.callbacks = RightSaxParserCallback.new(self) 
+        else 
+          xml.on_start_element{|name, attr_hash| self.tag_start(name, attr_hash)} 
+          xml.on_characters{   |text|            self.text(text)} 
+          xml.on_end_element{  |name|            self.tag_end(name)} 
+        end 
         xml.parse
       else
-        if @logger && @xml_lib!='rexml'
-          @logger.info "RightAWSParser#parse: Unknown xml library ('#{@xml_lib}') is selected. The default 'rexml' is used."
-        end
         REXML::Document.parse_stream(xml_text, self)
       end
     end

data/lib/ec2/right_ec2.rb

@@ -68,7 +68,7 @@ module RightAws
     
     SIGNATURE_VERSION = "1"
     # Amazon EC2 API version being used
-    API_VERSION       = "2007-03-01"
+    API_VERSION       = "2007-08-29"
     DEFAULT_HOST      = "ec2.amazonaws.com"
     DEFAULT_PROTOCOL  = 'https'
     DEFAULT_PORT      = 443
@@ -76,7 +76,11 @@ module RightAws
     # Default addressing type (public=NAT, direct=no-NAT) used when launching instances.
     DEFAULT_ADDRESSING_TYPE =  'public'
     DNS_ADDRESSING_SET      = ['public','direct']
-
+    
+    # Default EC2 instance type (platform) 
+    DEFAULT_INSTANCE_TYPE   =  'm1.small' 
+    INSTANCE_TYPES          = ['m1.small','m1.large','m1.xlarge'] 
+    
     @@bench = AwsBenchmarkingBlock.new
     def self.bench_xml
       @@bench.xml
@@ -85,6 +89,12 @@ module RightAws
       @@bench.service
     end
     
+     # Current API version (sometimes we have to check it outside the GEM).
+    @@api = ENV['EC2_API_VERSION'] || API_VERSION
+    def self.api 
+      @@api
+    end
+    
     # Create a new handle to an EC2 account. All handles share the same per process or per thread
     # HTTP connection to Amazon EC2. Each handle is for a specific account. The params have the
     # following options:
@@ -94,9 +104,14 @@ module RightAws
     # * <tt>:multi_thread</tt>: true=HTTP connection per thread, false=per process
     # * <tt>:logger</tt>: for log messages, default: RAILS_DEFAULT_LOGGER else STDOUT
     #
-    def initialize(aws_access_key_id, aws_secret_access_key, params={})
-      init({:name=>'EC2', :default_host => DEFAULT_HOST, :default_port => DEFAULT_PORT, :default_protocol => DEFAULT_PROTOCOL}, 
-           aws_access_key_id, aws_secret_access_key, params)
+    def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
+      init({ :name             => 'EC2', 
+             :default_host     => ENV['EC2_URL'] ? URI.parse(ENV['EC2_URL']).host   : DEFAULT_HOST, 
+             :default_port     => ENV['EC2_URL'] ? URI.parse(ENV['EC2_URL']).port   : DEFAULT_PORT, 
+             :default_protocol => ENV['EC2_URL'] ? URI.parse(ENV['EC2_URL']).scheme : DEFAULT_PROTOCOL }, 
+           aws_access_key_id    || ENV['AWS_ACCESS_KEY_ID'] , 
+           aws_secret_access_key|| ENV['AWS_SECRET_ACCESS_KEY'],
+           params)
     end
 
 
@@ -104,7 +119,7 @@ module RightAws
       timestamp    = ( Time::now ).utc.strftime("%Y-%m-%dT%H:%M:%S.000Z")
       request_hash = {"Action"            => action,
                       "AWSAccessKeyId"    => @aws_access_key_id,
-                      "Version"           => API_VERSION,
+                      "Version"           => @@api,
                       "Timestamp"         => timestamp,
                       "SignatureVersion"  => SIGNATURE_VERSION }
       request_hash.update(param)
@@ -139,18 +154,26 @@ module RightAws
   #-----------------------------------------------------------------
   #-----------------------------------------------------------------
 
-    def ec2_describe_images(type, list) #:nodoc:
+    def ec2_describe_images(type, list, &block) #:nodoc:
       link   = generate_request("DescribeImages", hash_params(type,list.to_a))
-      images = request_info(link, QEc2DescribeImagesParser.new(:logger => @logger))
-      images.collect! do |image|
-                    {:aws_id            => image.imageId,
-                     :aws_location      => image.imageLocation,
-                     :aws_owner         => image.imageOwnerId,
-                     :aws_state         => image.imageState.downcase,
-                     :aws_is_public     => image.isPublic,
-                     :aws_product_codes => image.productCodes}
+      # We do not want to break the logic of parsing hence will use a dummy parser to process all the standart 
+      # steps (errors checking etc). The dummy parser does nothig - just returns back the params it received.
+      # Then call the block (if it is) with the response. If the block returns +nil+ or +false+ then do not process
+      # real response parsing and exit with +nil+. Otherwise process parsing and return its result.
+      response, params = request_info(link, QEc2DummyParser.new)
+      if block
+        return nil unless block.call(response)
+      end
+      parser = QEc2DescribeImagesParser.new(:logger => @logger)
+      @@bench.xml.add!{ parser.parse(response, params) }
+      parser.result.collect do |image|
+        { :aws_id            => image.imageId,
+          :aws_location      => image.imageLocation,
+          :aws_owner         => image.imageOwnerId,
+          :aws_state         => image.imageState.downcase,
+          :aws_is_public     => image.isPublic,
+          :aws_product_codes => image.productCodes }
       end
-      images
     rescue Exception
       on_exception
     end
@@ -175,8 +198,19 @@ module RightAws
       #      :aws_location => "marcins_cool_public_images/ubuntu-6.10.manifest.xml",
       #      :aws_is_public => true}]
       #
-    def describe_images(list=[])
-      ec2_describe_images('ImageId', list)
+      # If a block is given then yields a respose before parsing. 
+      # If the block returns +false+ or +nil+ the response is not parsed
+      # and describe_images returns +nil+.
+      # 
+      #  images = ec2.describe_images do |response|
+      #    # Compare the response to the previous. If they are the same skip parsing - nothing
+      #    # has changed at Amazon. Skpping the parsing will save us a lots of time for the big
+      #    # responses.
+      #    response.body == previous_response_body ? false : true
+      #  end
+      #
+    def describe_images(list=[], &block)
+      ec2_describe_images('ImageId', list, &block)
     end
 
       #
@@ -185,8 +219,8 @@ module RightAws
       #  ec2.describe_images_by_owner('522821470517')
       #  ec2.describe_images_by_owner('self')
       #
-    def describe_images_by_owner(list)
-      ec2_describe_images('Owner', list)
+    def describe_images_by_owner(list, &block)
+      ec2_describe_images('Owner', list, &block)
     end
 
       #
@@ -195,8 +229,8 @@ module RightAws
       #  ec2.describe_images_by_executable_by('522821470517')
       #  ec2.describe_images_by_executable_by('self')
       #
-    def describe_images_by_executable_by(list)
-      ec2_describe_images('ExecutableBy', list)
+    def describe_images_by_executable_by(list, &block)
+      ec2_describe_images('ExecutableBy', list, &block)
     end
 
 
@@ -344,7 +378,8 @@ module RightAws
                      :ssh_key_name       => instance.keyName,
                      :aws_image_id       => instance.imageId,
                      :aws_reason         => reason,
-                     :aws_product_codes  => instance.productCodes}
+                     :aws_product_codes  => instance.productCodes,
+                     :aws_instance_type  => instance.instanceType}
         end
       end
       result
@@ -366,13 +401,30 @@ module RightAws
       #      :dns_name           => "domU-12-34-67-89-01-C9.usma2.compute.amazonaws.com",
       #      :ssh_key_name       => "staging",
       #      :aws_groups         => ["default"],
-      #      :private_dns_name   => "domU-12-34-67-89-01-C9.usma2.compute.amazonaws.com"},
+      #      :private_dns_name   => "domU-12-34-67-89-01-C9.usma2.compute.amazonaws.com",
+      #      :aws_instance_type  => "m1.small"}, 
       #       ..., {...}]
       #
-    def describe_instances(list=[])
-      link      = generate_request("DescribeInstances", hash_params('InstanceId',list.to_a))
-      instances = request_info(link, QEc2DescribeInstancesParser.new(:logger => @logger))
-      get_desc_instances(instances)
+      # If a block is given then yields a respose before parsing. 
+      # If the block returns +false+ or +nil+ the response is not parsed
+      # and describe_instances returns +nil+.
+      # 
+      #  instances = ec2.describe_instances do |response|
+      #    # Compare the response to the previous. If they are the same skip parsing - nothing
+      #    # has changed at Amazon. Skpping the parsing will save us a lots of time for the big
+      #    # responses.
+      #    response.body == previous_response_body ? false : true
+      #  end
+      #
+    def describe_instances(list=[], &block)
+      link = generate_request("DescribeInstances", hash_params('InstanceId',list.to_a))
+      response, params = request_info(link, QEc2DummyParser.new)
+      if block
+        return nil unless block.call(response)
+      end
+      parser = QEc2DescribeInstancesParser.new(:logger => @logger)
+      @@bench.xml.add!{ parser.parse(response, params) }
+      get_desc_instances(parser.result)
     rescue Exception
       on_exception
     end
@@ -401,24 +453,77 @@ module RightAws
       #     :dns_name           => "",
       #     :ssh_key_name       => "my_awesome_key",
       #     :aws_groups         => ["my_awesome_group"],
-      #     :private_dns_name   => ""}]
+      #     :private_dns_name   => "",
+      #     :aws_instance_type  => "m1.small"}]
       #
-    def run_instances(image_id, min_count, max_count, group_ids, key_name, user_data='', addressing_type=DEFAULT_ADDRESSING_TYPE)
-      @logger.info("Launching instance of image #{image_id} for #{@aws_access_key_id}, key: #{key_name}, groups: #{(group_ids||[]).to_a.join(',')}")
+    def run_instances(image_id, min_count, max_count, group_ids, key_name, user_data='',  
+                      addressing_type = DEFAULT_ADDRESSING_TYPE,  
+                      instance_type   = DEFAULT_INSTANCE_TYPE) 
+ 	    launch_instances(image_id, { :min_count       => min_count, 
+ 	                                 :max_count       => max_count, 
+ 	                                 :user_data       => user_data, 
+                                   :group_ids       => group_ids, 
+                                   :key_name        => key_name, 
+                                   :instance_type   => instance_type, 
+                                   :addressing_type => addressing_type }) 
+    end
+    
+     
+      # Launch new EC2 instances. Returns a list of launched instances or an exception. 
+      # 
+      # lparams and their default values: 
+      #  :min_count       - 1  
+      #  :max_count       - 1 
+      #  :user_data       - '' 
+      #  :group_ids       - [] # == 'default' 
+      #  :key_name        - nil 
+      #  :instance_type   - DEFAULT_INSTACE_TYPE 
+      #  :addressing_type - DEFAULT_ADDRESSING_TYPE 
+      # 
+      #  ec2.launch_instances('ami-e444444d', 'my_awesome_group', :user_data => "Woohoo!!!", \ 
+      #   :addressing_type => "public", :key_name => "my_awesome_key") #=> 
+      #   [{:aws_image_id       => "ami-e444444d", 
+      #     :aws_reason         => "", 
+      #     :aws_state_code     => "0", 
+      #     :aws_owner          => "000000000888", 
+      #     :aws_instance_id    => "i-123f1234", 
+      #     :aws_reservation_id => "r-aabbccdd", 
+      #     :aws_state          => "pending", 
+      #     :dns_name           => "", 
+      #     :ssh_key_name       => "my_awesome_key", 
+      #     :aws_groups         => ["default"], 
+      #     :private_dns_name   => "", 
+      #     :aws_instance_type  => "m1.small"}] 
+      #     
+    def launch_instances(image_id, lparams={}) 
+      defaults = { 
+        :min_count       => 1, 
+        :max_count       => 1, 
+        :user_data       => '', 
+        :group_ids       => [], 
+        :key_name        => nil, 
+        :instance_type   => DEFAULT_INSTANCE_TYPE, 
+        :addressing_type => DEFAULT_ADDRESSING_TYPE 
+      } 
+      lparams = defaults.merge(lparams) 
+      
+      @logger.info("Launching instance of image #{image_id} for #{@aws_access_key_id}, " + 
+                   "key: #{lparams[:key_name]}, groups: #{(lparams[:group_ids]||[]).to_a.join(',')}")
         # careful: keyName and securityGroups may be nil
-      params = hash_params('SecurityGroup', group_ids.to_a)
+      params = hash_params('SecurityGroup', lparams[:group_ids].to_a)
       params.update( {'ImageId'        => image_id,
-                      'MinCount'       => min_count.to_s,
-                      'MaxCount'       => max_count.to_s,
-                      'AddressingType' => addressing_type })
-      params['KeyName']  = key_name unless key_name.blank?
-      unless user_data.blank?
-        user_data.strip!
+                      'MinCount'       => lparams[:min_count].to_s, 
+                      'MaxCount'       => lparams[:max_count].to_s, 
+                      'AddressingType' => lparams[:addressing_type] }) 
+      params['InstanceType'] = lparams[:instance_type]
+      params['KeyName']      = lparams[:key_name] unless lparams[:key_name].blank? 
+      unless lparams[:user_data].blank? 
+        lparams[:user_data].strip! 
           # Do not use CGI::escape(encode64(...)) as it is done in Amazons EC2 library.
           # Amazon 169.254.169.254 does not like escaped symbols!
           # And it doesn't like "\n" inside of encoded string! Grrr....
           # Otherwise, some of UserData symbols will be lost...
-        params['UserData'] = Base64.encode64(user_data).delete("\n") unless user_data.blank?
+        params['UserData'] = Base64.encode64(lparams[:user_data]).delete("\n") unless lparams[:user_data].blank?
       end
       link = generate_request("RunInstances", params)
         #debugger
@@ -501,12 +606,28 @@ module RightAws
       #         {:to_port => "443", :protocol => "tcp",  :from_port => "443", :cidr_ips => "0.0.0.0/0"}]},
       #    ..., {...}]
       #
-    def describe_security_groups(list=[])
+      # If a block is given then yields a respose before parsing. 
+      # If the block returns +false+ or +nil+ the response is not parsed
+      # and describe_security_groups returns +nil+.
+      # 
+      #  groups = ec2.describe_security_groups do |response|
+      #    # Compare the response to the previous. If they are the same skip parsing - nothing
+      #    # has changed at Amazon. Skpping the parsing will save us a lots of time for the big
+      #    # responses.
+      #    response.body == previous_response_body ? false : true
+      #  end
+      #
+    def describe_security_groups(list=[], &block)
       link   = generate_request("DescribeSecurityGroups", hash_params('GroupName',list.to_a))
-      groups = request_info(link, QEc2DescribeSecurityGroupsParser.new(:logger => @logger))
+      response, params = request_info(link, QEc2DummyParser.new)
+      if block
+        return nil unless block.call(response)
+      end
+      parser = QEc2DescribeSecurityGroupsParser.new(:logger => @logger)
+      @@bench.xml.add!{ parser.parse(response, params) }
       
       result = []     
-      groups.each do |item|
+      parser.result.each do |item|
         perms = []
         item.ipPermissions.each do |perm|
           perm.groups.each do |ngroup|
@@ -636,14 +757,29 @@ module RightAws
       #     {:aws_fingerprint=> "1e:29:30:47:58:6d:7b:8c:9f:08:11:20:3c:44:52:69:74:80:97:08", :aws_key_name=>"key-2"},
       #      ..., {...} ]
       #
-    def describe_key_pairs(list=[])
-      link   = generate_request("DescribeKeyPairs", hash_params('KeyName',list.to_a))
-      result = request_info(link, QEc2DescribeKeyPairParser.new(:logger => @logger))
-      result.collect! do |key|
-          {:aws_key_name    => key.keyName,
-           :aws_fingerprint => key.keyFingerprint }
+      # If a block is given then yields a respose before parsing. 
+      # If the block returns +false+ or +nil+ the response is not parsed
+      # and describe_key_pairs returns +nil+.
+      # 
+      #  keys = ec2.describe_key_pairs do |response|
+      #    # Compare the response to the previous. If they are the same skip parsing - nothing
+      #    # has changed at Amazon. Skpping the parsing will save us a lots of time for the big
+      #    # responses.
+      #    response.body == previous_response_body ? false : true
+      #  end
+      #
+    def describe_key_pairs(list=[], &block)
+      link = generate_request("DescribeKeyPairs", hash_params('KeyName',list.to_a))
+      response, params = request_info(link, QEc2DummyParser.new)
+      if block
+        return nil unless block.call(response)
+      end
+      parser = QEc2DescribeKeyPairParser.new(:logger => @logger)
+      @@bench.xml.add!{ parser.parse(response, params) }
+      parser.result.collect do |key|
+        { :aws_key_name    => key.keyName,
+          :aws_fingerprint => key.keyFingerprint }
       end
-      result   
     rescue Exception
       on_exception
     end
@@ -685,7 +821,7 @@ module RightAws
   #      PARSERS: Boolean Response Parser
   #-----------------------------------------------------------------
     
-  class RightBoolResponseParser < RightAWSParser
+  class RightBoolResponseParser < RightAWSParser #:nodoc:
     def tagend(name)
       @result = @text=='true' ? true : false if name == 'return'
     end
@@ -695,16 +831,16 @@ module RightAws
   #      PARSERS: Key Pair
   #-----------------------------------------------------------------
 
-    class QEc2DescribeKeyPairType
+    class QEc2DescribeKeyPairType #:nodoc:
       attr_accessor :keyName 
       attr_accessor :keyFingerprint
     end
 
-    class QEc2CreateKeyPairType < QEc2DescribeKeyPairType
+    class QEc2CreateKeyPairType < QEc2DescribeKeyPairType #:nodoc:
       attr_accessor :keyMaterial
     end
 
-    class QEc2DescribeKeyPairParser < RightAWSParser
+    class QEc2DescribeKeyPairParser < RightAWSParser #:nodoc:
       def tagstart(name, attributes)
         @item = QEc2DescribeKeyPairType.new if name == 'item'
       end
@@ -720,7 +856,7 @@ module RightAws
       end
     end
 
-    class QEc2CreateKeyPairParser < RightAWSParser
+    class QEc2CreateKeyPairParser < RightAWSParser #:nodoc:
       def tagstart(name, attributes)
         @result = QEc2CreateKeyPairType.new if !@result
       end
@@ -737,12 +873,12 @@ module RightAws
   #      PARSERS: Security Groups
   #-----------------------------------------------------------------
 
-    class QEc2UserIdGroupPairType
+    class QEc2UserIdGroupPairType #:nodoc:
       attr_accessor :userId
       attr_accessor :groupName
     end
 
-    class QEc2IpPermissionType
+    class QEc2IpPermissionType #:nodoc:
       attr_accessor :ipProtocol
       attr_accessor :fromPort
       attr_accessor :toPort
@@ -750,7 +886,7 @@ module RightAws
       attr_accessor :ipRanges
     end
 
-    class QEc2SecurityGroupItemType
+    class QEc2SecurityGroupItemType #:nodoc:
       attr_accessor :groupName
       attr_accessor :groupDescription
       attr_accessor :ownerId
@@ -758,7 +894,7 @@ module RightAws
     end
 
 
-    class QEc2DescribeSecurityGroupsParser < RightAWSParser
+    class QEc2DescribeSecurityGroupsParser < RightAWSParser #:nodoc:
       def tagstart(name, attributes)
         case name
           when 'item' 
@@ -808,7 +944,7 @@ module RightAws
   #      PARSERS: Images
   #-----------------------------------------------------------------
 
-    class QEc2DescribeImagesResponseItemType
+    class QEc2DescribeImagesResponseItemType #:nodoc:
       attr_accessor :imageId 
       attr_accessor :imageState 
       attr_accessor :imageLocation
@@ -817,7 +953,7 @@ module RightAws
       attr_accessor :productCodes
     end
 
-    class QEc2DescribeImagesParser < RightAWSParser
+    class QEc2DescribeImagesParser < RightAWSParser #:nodoc:
       def tagstart(name, attributes)
         if name == 'item' && @xmlpath[%r{.*/imagesSet$}]
           @image = QEc2DescribeImagesResponseItemType.new 
@@ -839,7 +975,7 @@ module RightAws
       end
     end
 
-    class QEc2RegisterImageParser < RightAWSParser
+    class QEc2RegisterImageParser < RightAWSParser #:nodoc:
       def tagend(name)
         @result = @text if name == 'imageId'
       end
@@ -849,18 +985,18 @@ module RightAws
   #      PARSERS: Image Attribute
   #-----------------------------------------------------------------
 
-    class QEc2LaunchPermissionItemType
+    class QEc2LaunchPermissionItemType #:nodoc:
       attr_accessor :groups
       attr_accessor :userIds
     end
     
-    class QEc2DescribeImageAttributeType
+    class QEc2DescribeImageAttributeType #:nodoc:
       attr_accessor :imageId 
       attr_accessor :launchPermission
       attr_accessor :productCodes
     end
 
-    class QEc2DescribeImageAttributeParser < RightAWSParser
+    class QEc2DescribeImageAttributeParser < RightAWSParser #:nodoc:
       def tagstart(name, attributes)
         case name
           when 'launchPermission'
@@ -892,12 +1028,12 @@ module RightAws
   #      PARSERS: Instances
   #-----------------------------------------------------------------
 
-    class QEc2InstanceStateType
+    class QEc2InstanceStateType #:nodoc:
       attr_accessor :code
       attr_accessor :name
     end
 
-    class QEc2RunningInstancesItemType
+    class QEc2RunningInstancesItemType #:nodoc:
       attr_accessor :instanceId
       attr_accessor :imageId
       attr_accessor :instanceState
@@ -907,16 +1043,17 @@ module RightAws
       attr_accessor :keyName
       attr_accessor :amiLaunchIndex
       attr_accessor :productCodes
+      attr_accessor :instanceType
     end
 
-    class QEc2DescribeInstancesType
+    class QEc2DescribeInstancesType #:nodoc:
       attr_accessor :reservationId
       attr_accessor :ownerId
       attr_accessor :groupSet
       attr_accessor :instancesSet 
     end
 
-    class QEc2DescribeInstancesParser < RightAWSParser
+    class QEc2DescribeInstancesParser < RightAWSParser #:nodoc:
       def tagstart(name, attributes)
         case name
           when 'item'
@@ -957,6 +1094,7 @@ module RightAws
               @result << @reservation
             end
           when 'productCode'   ; (@instance.productCodes ||= []) << @text
+          when 'instanceType'  ; @instance.instanceType = @text
         end
       end
       def reset
@@ -964,7 +1102,7 @@ module RightAws
       end
     end
 
-    class QEc2ConfirmProductInstanceParser < RightAWSParser
+    class QEc2ConfirmProductInstanceParser < RightAWSParser #:nodoc:
       def tagend(name)
         @result = @text if name == 'ownerId'
       end
@@ -973,7 +1111,7 @@ module RightAws
       end
     end
 
-    class QEc2RunInstancesParser < RightAWSParser
+    class QEc2RunInstancesParser < RightAWSParser #:nodoc:
       def tagstart(name, attributes)
         case name
           when 'RunInstancesResponse'
@@ -1011,6 +1149,7 @@ module RightAws
             @reservation.instancesSet << @instance if @xmlpath == 'RunInstancesResponse/instancesSet'
           when 'RunInstancesResponse'; @result << @reservation
           when 'productCode'   ; (@instance.productCodes ||= []) << @text
+          when 'instanceType'  ; @instance.instanceType = @text
         end
       end
       def reset
@@ -1018,13 +1157,13 @@ module RightAws
       end
     end
 
-    class QEc2TerminateInstancesResponseInfoType
+    class QEc2TerminateInstancesResponseInfoType #:nodoc:
       attr_accessor :instanceId
       attr_accessor :shutdownState
       attr_accessor :previousState
     end
 
-    class QEc2TerminateInstancesParser < RightAWSParser
+    class QEc2TerminateInstancesParser < RightAWSParser #:nodoc:
       def tagstart(name, attributes)
         if name == 'item'
           @instance = QEc2TerminateInstancesResponseInfoType.new 
@@ -1055,13 +1194,13 @@ module RightAws
   #      PARSERS: Console
   #-----------------------------------------------------------------
 
-    class QEc2GetConsoleOutputResponseType
+    class QEc2GetConsoleOutputResponseType #:nodoc:
       attr_accessor :instanceId
       attr_accessor :timestamp
       attr_accessor :output
     end
 
-    class QEc2GetConsoleOutputParser < RightAWSParser
+    class QEc2GetConsoleOutputParser < RightAWSParser #:nodoc:
       def tagend(name)
         case name
         when 'instanceId' ; @result.instanceId = @text
@@ -1076,4 +1215,17 @@ module RightAws
 
   end
 
+  #-----------------------------------------------------------------
+  #      PARSERS: Fake
+  #-----------------------------------------------------------------
+  
+    # Dummy parser - does nothing
+    # Returns the original params back
+    class QEc2DummyParser  # :nodoc:
+      attr_accessor :result
+      def parse(response, params={})
+        @result = [response, params]
+      end
+    end
+  
 end

data/lib/right_aws.rb

@@ -48,8 +48,8 @@ require 'sqs/right_sqs'
 module RightAws #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 1
-    MINOR = 3
-    TINY  = 0
+    MINOR = 4
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/s3/right_s3.rb

@@ -41,7 +41,7 @@ module RightAws
     # Create a new handle to an S3 account. All handles share the same per process or per thread
     # HTTP connection to Amazon S3. Each handle is for a specific account.
     # The +params+ are passed through as-is to RightAws::S3Interface.new
-    def initialize(aws_access_key_id, aws_secret_access_key, params={})
+    def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
       @interface = S3Interface.new(aws_access_key_id, aws_secret_access_key, params)
     end
     

data/lib/s3/right_s3_interface.rb

@@ -55,9 +55,14 @@ module RightAws
       #     :multi_thread => true|false           # Multi-threaded (connection per each thread): true or false(default)
       #     :logger       => Logger Object}       # Logger instance: logs to STDOUT if omitted }
       #
-    def initialize(aws_access_key_id, aws_secret_access_key, params={})
-      init({:name=>'S3', :default_host => DEFAULT_HOST, :default_port => DEFAULT_PORT, :default_protocol => DEFAULT_PROTOCOL}, 
-           aws_access_key_id, aws_secret_access_key, params)
+    def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
+      init({ :name             => 'S3', 
+             :default_host     => ENV['S3_URL'] ? URI.parse(ENV['S3_URL']).host   : DEFAULT_HOST, 
+             :default_port     => ENV['S3_URL'] ? URI.parse(ENV['S3_URL']).port   : DEFAULT_PORT, 
+             :default_protocol => ENV['S3_URL'] ? URI.parse(ENV['S3_URL']).scheme : DEFAULT_PROTOCOL }, 
+           aws_access_key_id     || ENV['AWS_ACCESS_KEY_ID'], 
+           aws_secret_access_key || ENV['AWS_SECRET_ACCESS_KEY'], 
+           params)
     end
 
 

data/lib/sqs/right_sqs.rb

@@ -58,7 +58,7 @@ module RightAws
   class Sqs
     attr_reader :interface
     
-    def initialize(aws_access_key_id, aws_secret_access_key, params={})
+    def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
       @interface = SqsInterface.new(aws_access_key_id, aws_secret_access_key, params)
     end
     

data/lib/sqs/right_sqs_interface.rb

@@ -43,6 +43,10 @@ module RightAws
       @@bench.service
     end
 
+    @@api = API_VERSION
+    def self.api 
+      @@api
+    end
 
       # Creates a new SqsInterface instance.
       #
@@ -55,9 +59,14 @@ module RightAws
       #     :multi_thread => true|false            # Multi-threaded (connection per each thread): true or false(default)
       #     :logger       => Logger Object}        # Logger instance: logs to STDOUT if omitted }
       #
-    def initialize(aws_access_key_id, aws_secret_access_key, params={})
-      init({:name=>'SQS', :default_host => DEFAULT_HOST, :default_port => DEFAULT_PORT, :default_protocol => DEFAULT_PROTOCOL}, 
-           aws_access_key_id, aws_secret_access_key, params)
+    def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
+      init({ :name             => 'SQS', 
+             :default_host     => ENV['SQS_URL'] ? URI.parse(ENV['SQS_URL']).host   : DEFAULT_HOST, 
+             :default_port     => ENV['SQS_URL'] ? URI.parse(ENV['SQS_URL']).port   : DEFAULT_PORT, 
+             :default_protocol => ENV['SQS_URL'] ? URI.parse(ENV['SQS_URL']).scheme : DEFAULT_PROTOCOL }, 
+           aws_access_key_id     || ENV['AWS_ACCESS_KEY_ID'], 
+           aws_secret_access_key || ENV['AWS_SECRET_ACCESS_KEY'], 
+           params)
     end
 
 

data/test/http_connection.rb

@@ -23,6 +23,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 # Stub extension/redefinition of RightHttpConnection for testing purposes.
 require 'net/http'
+require 'rubygems'
 require 'right_http_connection'
 
 module Net
@@ -33,7 +34,8 @@ module Net
     end
 
     def body
-      @mymsg ? @mymsg : real_body
+      # defined?() helps us to get rid of a bunch of 'warnings'
+      (defined?(@mymsg) && @mymsg) ? @mymsg : real_body
     end
   end
 end

data/test/sqs/test_right_sqs.rb

@@ -13,6 +13,24 @@ class TestSqs < Test::Unit::TestCase
     @s = Rightscale::Sqs.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
   end
   
+  # Wait for the queue to appears in the queues list.
+  # Amazon needs some time to after the queue creation to place
+  # it to the accessible queues list. If we dont want to get
+  # the additional faults then wait a bit...
+  def wait_for_queue_url(queue_name)
+    queue_url = nil
+    until queue_url
+      queue_url = @sqs.queue_url_by_name(queue_name)
+      unless queue_url
+        print '-' 
+        STDOUT.flush
+        sleep 1
+      end
+    end
+    queue_url
+  end
+  
+  
   #---------------------------
   # Rightscale::SqsInterface
   #---------------------------
@@ -23,6 +41,7 @@ class TestSqs < Test::Unit::TestCase
   end
 
   def test_02_list_queues
+    wait_for_queue_url(@queue_name)
     queues = @sqs.list_queues('right_')
     assert queues.size>0, 'Must more that 0 queues in list'
   end
@@ -31,14 +50,14 @@ class TestSqs < Test::Unit::TestCase
     queue_url = @sqs.queue_url_by_name(@queue_name)
     assert queue_url[/http.*#{@queue_name}/], "#{@queue_name} must exist!"
     assert @sqs.set_queue_attributes(queue_url, 'VisibilityTimeout', 111), 'Set_queue_attributes fail'
-    sleep 10 # Amazon needs some time to change attribute
+    sleep 20 # Amazon needs some time to change attribute
     assert_equal '111', @sqs.get_queue_attributes(queue_url)['VisibilityTimeout'], 'New VisibilityTimeout must be equal to 111'
   end
   
   def test_04_set_and_get_visibility_timeout
     queue_url = @sqs.queue_url_by_name(@queue_name)
     assert @sqs.set_visibility_timeout(queue_url, 222), 'Set_visibility_timeout fail'
-    sleep 10 # Amazon needs some time to change attribute
+    sleep 20 # Amazon needs some time to change attribute
     assert_equal 222, @sqs.get_visibility_timeout(queue_url), 'Get_visibility_timeout must return to 222'
   end
   
@@ -103,6 +122,7 @@ class TestSqs < Test::Unit::TestCase
     queue  = @s.queue("#{@queue_name}_20", true)
       # check that it is created
     assert queue.is_a?(Rightscale::Sqs::Queue)
+    wait_for_queue_url(@queue_name)
       # check that amount of queues has increased
     assert_equal queues_size + 1, @s.queues.size
       # delete queue
@@ -114,10 +134,10 @@ class TestSqs < Test::Unit::TestCase
     queue = Rightscale::Sqs::Queue.create(@s, "#{@queue_name}_21", true)
       # check that it is created
     assert queue.is_a?(Rightscale::Sqs::Queue)
+    wait_for_queue_url(@queue_name)
   end
   
   def test_22_queue_attributes
-    sleep 10
     queue = Rightscale::Sqs::Queue.create(@s, "#{@queue_name}_21", false)
       # get a list of attrinutes
     attributes = queue.get_attribute
@@ -127,7 +147,7 @@ class TestSqs < Test::Unit::TestCase
       # set attribute
     assert queue.set_attribute('VisibilityTimeout', v)
       # wait a bit
-    sleep 10
+    sleep 20
       # check that attribute has changed
     assert_equal v, queue.get_attribute('VisibilityTimeout')
       # get queue visibility timeout
@@ -219,14 +239,14 @@ class TestSqs < Test::Unit::TestCase
   end
 
   def test_27_set_amazon_problems
-    original_problems = RightAws::SqsInterface.amazon_problems
+    original_problems = Rightscale::SqsInterface.amazon_problems
     assert(original_problems.length > 0)
-    RightAws::SqsInterface.amazon_problems= original_problems << "A New Problem"
-    new_problems = RightAws::SqsInterface.amazon_problems
+    Rightscale::SqsInterface.amazon_problems= original_problems << "A New Problem"
+    new_problems = Rightscale::SqsInterface.amazon_problems
     assert_equal(new_problems, original_problems)
 
-    RightAws::SqsInterface.amazon_problems= nil
-    assert_nil(RightAws::SqsInterface.amazon_problems)
+    Rightscale::SqsInterface.amazon_problems= nil
+    assert_nil(Rightscale::SqsInterface.amazon_problems)
   end
 
   def test_28_check_threading_model

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
+rubygems_version: 0.9.0
 specification_version: 1
 name: right_aws
 version: !ruby/object:Gem::Version 
-  version: 1.3.0
-date: 2007-09-26 00:00:00 -07:00
+  version: 1.4.2
+date: 2007-10-18 00:00:00 +04:00
 summary: Interface classes for the Amazon EC2, SQS, and S3 Web Services
 require_paths: 
 - lib
@@ -75,7 +75,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.1.4
+        version: 1.2.0
     version: 
 - !ruby/object:Gem::Dependency 
   name: hoe