aws 2.2.5 → 2.2.6

data/lib/aws.rb

@@ -16,6 +16,7 @@ $:.unshift(File.dirname(__FILE__))
 require 'awsbase/benchmark_fix'
 require 'awsbase/support'
 require 'awsbase/right_awsbase'
+require 'awsbase/aws_response_array'
 require 'ec2/right_ec2'
 require 'ec2/right_mon_interface'
 require 's3/right_s3_interface'

data/lib/awsbase/aws_response_array.rb

@@ -0,0 +1,30 @@
+module Aws
+
+    # This class is a special array to hold a bit of extra information about a response like:
+    # <ResponseMetadata>
+    #    <RequestId>4f1fae46-bf3d-11de-a88b-7b5b3d23b3a7</RequestId>
+    #  </ResponseMetadata>
+    #
+    # Which can be accessed directly from the array using array.response_metadata
+    #
+    class AwsResponseArray < Array
+
+        attr_accessor :response_metadata
+
+        def initialize(response_metadata)
+            @response_metadata = response_metadata
+        end
+
+    end
+
+    # Used when pulling out a single response object
+    class AwsResponseObjectHash < Hash
+
+        attr_accessor :response_metadata
+
+        def initialize(response_metadata)
+            @response_metadata = response_metadata
+        end
+
+    end
+end

data/lib/awsbase/right_awsbase.rb

@@ -28,6 +28,7 @@ module Aws
     require 'cgi'
     require 'uri'
     require 'xmlsimple'
+    require 'active_support'
 
     class AwsUtils #:nodoc:
         @@digest1 = OpenSSL::Digest::Digest.new("sha1")
@@ -321,15 +322,16 @@ module Aws
         end
 
         # This is the direction we should head instead of writing our own parsers for everything, much simpler
+        # params:
+        #  - :group_tags => hash of indirection to eliminate, see: http://xml-simple.rubyforge.org/
+        #  - :force_array => true for all or an array of tag names to force
+        #  - :pull_out_array => an array of levels to dig into when generating return value (see rds.rb for example)
         def request_info_xml_simple(connection_name, lib_params, request, logger, params = {})
 
             @connection = get_conn(connection_name, lib_params, logger)
             @last_request = request[:request]
             @last_response = nil
 
-            response = nil
-            blockexception = nil
-
             response = @connection.request(request)
 #            benchblock.service.add!{ response = @connection.request(request) }
             # check response for errors...
@@ -339,7 +341,51 @@ module Aws
 #                benchblock.xml.add! { parser.parse(response) }
 #                return parser.result
                 force_array = params[:force_array] || false
-                return XmlSimple.xml_in(response.body, {"KeyToSymbol"=>false, 'ForceArray' => force_array})
+                # Force_array and group_tags don't work nice together so going to force array manually
+                xml_simple_options = {"KeyToSymbol"=>false, 'ForceArray' => false}
+                xml_simple_options["GroupTags"] = params[:group_tags] if params[:group_tags]
+
+#                { 'GroupTags' => { 'searchpath' => 'dir' }
+#                'ForceArray' => %r(_list$)
+                parsed = XmlSimple.xml_in(response.body, xml_simple_options)
+                # todo: we may want to consider stripping off a couple of layers when doing this, for instance:
+                # <DescribeDBInstancesResponse xmlns="http://rds.amazonaws.com/admin/2009-10-16/">
+                #  <DescribeDBInstancesResult>
+                #    <DBInstances>
+                # <DBInstance>....
+                # Strip it off and only return an array or hash of <DBInstance>'s (hash by identifier).
+                # would have to be able to make the RequestId available somehow though, perhaps some special array subclass which included that?
+                unless force_array.is_a? Array
+                    force_array = []
+                end
+                parsed = symbolize(parsed, force_array)
+#                puts 'parsed=' + parsed.inspect
+                if params[:pull_out_array]
+                    ret = Aws::AwsResponseArray.new(parsed[:response_metadata])
+                    level_hash = parsed
+                    params[:pull_out_array].each do |x|
+                        level_hash = level_hash[x]
+                    end
+                    if level_hash.is_a? Hash # When there's only one
+                        ret << level_hash
+                    else # should be array
+                        level_hash.each do |x|
+                            ret << x
+                        end
+                    end
+                elsif params[:pull_out_single]
+                    # returns a single object
+                    ret = AwsResponseObjectHash.new(parsed[:response_metadata])
+                    level_hash = parsed
+                    params[:pull_out_single].each do |x|
+                        level_hash = level_hash[x]
+                    end
+                    ret.merge!(level_hash)
+                else
+                    ret = parsed
+                end
+                return ret
+
             else
                 @error_handler = AWSErrorHandler.new(self, nil, :errors_list => self.class.amazon_problems) unless @error_handler
                 check_result = @error_handler.check(request)
@@ -353,38 +399,22 @@ module Aws
 
         end
 
-        # FROM ELB
-=begin
- def generate_request2(action, params={})
-            service_hash = {"Action" => action,
-                            "AWSAccessKeyId" => @aws_access_key_id,
-                            "Version" => @@api }
-            service_hash.update(params)
-            service_params = signed_service_params(@aws_secret_access_key, service_hash, :get, @params[:server], @params[:service])
-
-            # use POST method if the length of the query string is too large
-            if service_params.size > 2000
-                if signature_version == '2'
-                    # resign the request because HTTP verb is included into signature
-                    service_params = signed_service_params(@aws_secret_access_key, service_hash, :post, @params[:server], @params[:service])
+        def symbolize(hash, force_array)
+            ret = {}
+            hash.keys.each do |key|
+                val = hash[key]
+                if val.is_a? Hash
+                    val = symbolize(val, force_array)
+                    if force_array.include? key
+                        val = [val]
+                    end
+                elsif val.is_a? Array
+                    val = val.collect { |x| symbolize(x, force_array) }
                 end
-                request = Net::HTTP::Post.new(service)
-                request.body = service_params
-                request['Content-Type'] = 'application/x-www-form-urlencoded'
-            else
-                request = Net::HTTP::Get.new("#{@params[:service]}?#{service_params}")
+                ret[key.underscore.to_sym] = val
             end
-
-            #puts "\n\n --------------- QUERY REQUEST TO AWS -------------- \n\n"
-            #puts "#{@params[:service]}?#{service_params}\n\n"
-
-            # prepare output hash
-            { :request => request,
-              :server => @params[:server],
-              :port => @params[:port],
-              :protocol => @params[:protocol] }
+            ret
         end
-=end
 
         # Returns +true+ if the describe_xxx responses are being cached
         def caching?

data/lib/rds/rds.rb

@@ -51,6 +51,24 @@ module Aws
             generate_request2(@aws_access_key_id, @aws_secret_access_key, action, @@api, @params, params)
         end
 
+        def do_request(action, params, options={})
+            link = generate_request(action, params)
+            resp = request_info_xml_simple(:rds_connection, @params, link, @logger,
+                                           :group_tags=>{"DBInstances"=>"DBInstance",
+                                                            "DBParameterGroups"=>"DBParameterGroup",
+                                                            "DBSecurityGroups"=>"DBSecurityGroup",
+                                                            "EC2SecurityGroups"=>"EC2SecurityGroup",
+                                                            "IPRanges"=>"IPRange"},
+                                           :force_array=>["DBInstances",
+                                                          "DBParameterGroups",
+                                                          "DBSecurityGroups",
+                                                          "EC2SecurityGroups",
+                                                          "IPRanges"],
+                                           :pull_out_array=>options[:pull_out_array],
+                                           :pull_out_single=>options[:pull_out_single],
+                                           :wrapper=>options[:wrapper])
+        end
+
 
         #-----------------------------------------------------------------
         #      REQUESTS
@@ -81,8 +99,7 @@ module Aws
 
             @logger.info("Creating DB Instance called #{identifier}")
 
-            link = generate_request("CreateDBInstance", params)
-            resp = request_info_xml_simple(:rds_connection, @params, link, @logger)
+            link = do_request("CreateDBInstance", params, :pull_out_single=>[:create_db_instance_result, :db_instance])
 
         rescue Exception
             on_exception
@@ -93,14 +110,16 @@ module Aws
         #      DBInstanceIdentifier
         #      MaxRecords
         #      Marker
+        #
+        # Returns array of instances as hashes.
+        # Response metadata can be retreived by calling array.response_metadata on the returned array.
         def describe_db_instances(options={})
             params = {}
-            params['DBInstanceIdentifier'] = options[:DBInstanceIdentifier] if options[:DBInstanceIdentifier]
-            params['MaxRecords'] = options[:MaxRecords] if options[:MaxRecords]
-            params['Marker'] = options[:Marker] if options[:Marker]
+            params['DBInstanceIdentifier'] = options[:db_instance_identifier] if options[:db_instance_identifier]
+            params['MaxRecords'] = options[:max_records] if options[:max_records]
+            params['Marker'] = options[:marker] if options[:marker]
 
-            link = generate_request("DescribeDBInstances", params)
-            resp = request_info_xml_simple(:rds_connection, @params, link, @logger)
+            resp = do_request("DescribeDBInstances", params, :pull_out_array=>[:describe_db_instances_result, :db_instances])
 
         rescue Exception
             on_exception
@@ -120,21 +139,20 @@ module Aws
                 params['SkipFinalSnapshot'] = true
             end
 
-            link = generate_request("DeleteDBInstance", params)
-            resp = request_info_xml_simple(:rds_connection, @params, link, @logger)
+            link = do_request("DeleteDBInstance", params, :pull_out_single=>[:delete_db_instance_result, :db_instance])
 
         rescue Exception
             on_exception
         end
 
 
-        def create_db_security_groups(group_name, description, options={})
+        def create_db_security_group(group_name, description, options={})
             params = {}
             params['DBSecurityGroupName'] = group_name
             params['DBSecurityGroupDescription'] = description
-            params['Engine'] = options[:engine] || "MySQL5.1"
-            link = generate_request("CreateDBSecurityGroup", params)
-            resp = request_info_xml_simple(:rds_connection, @params, link, @logger)
+
+            link = do_request("CreateDBSecurityGroup", params, :pull_out_single => [:create_db_security_group_result, :db_security_group])
+
         rescue Exception
             on_exception
         end
@@ -143,8 +161,9 @@ module Aws
         def delete_db_security_group(group_name, options={})
             params = {}
             params['DBSecurityGroupName'] = group_name
-            link = generate_request("DeleteDBSecurityGroup", params)
-            resp = request_info_xml_simple(:rds_connection, @params, link, @logger)
+
+            link = do_request("DeleteDBSecurityGroup", params)
+
         rescue Exception
             on_exception
         end
@@ -155,10 +174,9 @@ module Aws
             params['DBSecurityGroupName'] = options[:DBSecurityGroupName] if options[:DBSecurityGroupName]
             params['MaxRecords'] = options[:MaxRecords] if options[:MaxRecords]
 
-            force_array = options[:force_array].nil? ? false : options[:force_array]
+            link = do_request("DescribeDBSecurityGroups", params, :pull_out_array=>[:describe_db_security_groups_result, :db_security_groups], :wrapper=>:db_security_group)
+
 
-            link = generate_request("DescribeDBSecurityGroups", params)
-            resp = request_info_xml_simple(:rds_connection, @params, link, @logger, :force_array => force_array)
         rescue Exception
             on_exception
         end
@@ -169,8 +187,7 @@ module Aws
             params['DBSecurityGroupName'] = group_name
             params['EC2SecurityGroupOwnerId'] = ec2_group_owner_id
             params['EC2SecurityGroupName'] = ec2_group_name
-            link = generate_request("AuthorizeDBSecurityGroupIngress", params)
-            resp = request_info_xml_simple(:rds_connection, @params, link, @logger)
+            link = do_request("AuthorizeDBSecurityGroupIngress", params)
         rescue Exception
             on_exception
         end
@@ -180,8 +197,7 @@ module Aws
             params = {}
             params['DBSecurityGroupName'] = group_name
             params['CIDRIP'] = ip_range
-            link = generate_request("AuthorizeDBSecurityGroupIngress", params)
-            resp = request_info_xml_simple(:rds_connection, @params, link, @logger)
+            link = do_request("AuthorizeDBSecurityGroupIngress", params)
         rescue Exception
             on_exception
         end
@@ -191,13 +207,13 @@ module Aws
             params = {}
             params['DBSecurityGroupName'] = group_name
             params['CIDRIP'] = ip_range
-            link = generate_request("RevokeDBSecurityGroupIngress", params)
-            resp = request_info_xml_simple(:rds_connection, @params, link, @logger)
+            link = do_request("RevokeDBSecurityGroupIngress", params)
         rescue Exception
             on_exception
         end
 
 
+
     end
 
 end

data/test/rds/test_rds.rb

@@ -15,7 +15,7 @@ class TestRds < Test::Unit::TestCase
         @rds = Aws::Rds.new(TestCredentials.aws_access_key_id,
                             TestCredentials.aws_secret_access_key)
 
-        @identifier = 'test-db-instance1'
+        @identifier = 'test-db-instance1b'
         # deleting this one....
         #@identifier2 = 'my-db-instance2'
     end
@@ -23,61 +23,69 @@ class TestRds < Test::Unit::TestCase
 
     def test_01_create_db_instance
         begin
-            db_instance3 = @rds.create_db_instance('right_ec2_awesome_test_key', "db.m1.small", 5, "master", "masterpass")
+            db_instance3 = @rds.create_db_instance('bad_test_key', "db.m1.small", 5, "master", "masterpass")
         rescue => ex
             #puts "msg=" + ex.message
             #puts "response=" + ex.response
             assert ex.message[0, "InvalidParameterValue".size] == "InvalidParameterValue"
         end
 
-        #db_instance = @rds.create_db_instance(@identifier, "db.m1.small", 5, "master", "masterpass")
+        db_instance = @rds.create_db_instance(@identifier, "db.m1.small", 5, "master", "masterpass")
+        assert db_instance[:db_instance_status] == "creating"
 
+        start = Time.now
         tries=0
-        while tries < 100
-            instances_result = @rds.describe_db_instances
-            instances = instances_result["DescribeDBInstancesResult"]["DBInstances"]["DBInstance"]
-
-            #puts "INSTANCES -----> " + instances.inspect
-
-            instances.each do |i|
-                next unless i["DBInstanceIdentifier"] == @identifier
-                break if i["DBInstanceStatus"] == "available"
-                puts "Database not ready yet.... attempt #{tries.to_s} of 100, db state --> #{i["DBInstanceStatus"].to_s}"
-                tries += 1
-                sleep 5
+        catch (:done)  do
+            while tries < 100
+                instances = @rds.describe_db_instances
+
+                #puts "INSTANCES -----> " + instances.inspect
+
+                instances.each do |i|
+                    db_status = i[:db_instance_status]
+                    puts 'i=' + db_status.to_s
+                    next unless i[:db_instance_identifier] == @identifier
+                    throw :done if db_status == "available"
+                    puts "Database not ready yet.... attempt #{tries.to_s} of 100, db state --> #{i[:db_instance_status].to_s}"
+                    tries += 1
+                    sleep 5
+                end
             end
-
-
         end
+        puts "Duration to start db instance: #{Time.now-start}"
     end
 
 
     def test_02_describe_db_instances
-        instances_result = @rds.describe_db_instances
-        #puts "instances_result=" + instances_result.inspect
-        instances = instances_result["DescribeDBInstancesResult"]["DBInstances"]["DBInstance"]
-        #puts "\n\ninstances count = " + instances.count.to_s + " \n\n "
-
+        instances = @rds.describe_db_instances
+#        puts "instances_result=" + instances_result.inspect
+#        instances = instances_result["DescribeDBInstancesResult"]["DBInstances"]["DBInstance"]
+        puts "instances count = " + instances.count.to_s
+        puts 'instances=' + instances.inspect
         assert instances.size > 0
+        i_describe = nil
+        instances.each do |x|
+            i_describe = x if x[:db_instance_identifier] == @identifier
+        end
+        assert i_describe
+
+        puts 'response_metadata=' + instances.response_metadata.inspect
+        assert instances.response_metadata
+        assert instances.response_metadata[:request_id]
     end
 
 
     def test_03_describe_security_groups
-        security_result = @rds.describe_db_security_groups()
-        #puts "security_result=" + security_result.inspect
-        security_groups=security_result["DescribeDBSecurityGroupsResult"]["DBSecurityGroups"]["DBSecurityGroup"]
+        security_groups = @rds.describe_db_security_groups()
+        puts "security_groups=" + security_groups.inspect
         default_present = false
-        if security_groups.is_a?(Array)
-            security_groups.each do |security_group|
-                security_group.inspect
-                if security_group["DBSecurityGroupName"]=="default"
-                    default_present=true
-                end
-            end
-        else
-            if security_groups["DBSecurityGroupName"]=="default"
+        assert security_groups.is_a?(Array)
+        security_groups.each do |security_group|
+            security_group.inspect
+            if security_group[:db_security_group_name] == "default"
                 default_present=true
             end
+            assert security_group[:ec2_security_groups].is_a? Array
         end
         assert default_present
     end
@@ -85,11 +93,13 @@ class TestRds < Test::Unit::TestCase
 
     def test_04_authorize_security_groups_ingress
         # Create
-        @security_info = @rds.describe_db_security_groups({:force_array => ["DBSecurityGroup", "IPRange"]})["DescribeDBSecurityGroupsResult"]["DBSecurityGroups"]["DBSecurityGroup"]
+#        security_groups = @rds.describe_db_security_groups
+#        @security_info = security_groups[0]
         @rds.authorize_db_security_group_ingress_range("default", "122.122.122.122/12")
 
         # Check
-        @security_info = @rds.describe_db_security_groups({:force_array => ["DBSecurityGroup", "IPRange"]})["DescribeDBSecurityGroupsResult"]["DBSecurityGroups"]["DBSecurityGroup"]
+        security_groups = @rds.describe_db_security_groups
+        @security_info = security_groups[0]
 
         ip_found = @security_info.inspect.include? "122.122.122.122/12"
         assert ip_found
@@ -97,31 +107,34 @@ class TestRds < Test::Unit::TestCase
 
 
     def test_05_delete_db_instance
-        @rds.delete_db_instance(@identifier)
+        @rds.delete_db_instance(@identifier) # todo: can't delete unless it's in "available" state
         #@rds.delete_db_instance(@identifier2)
         sleep 3
 
-        instances_result = @rds.describe_db_instances
+        instances = @rds.describe_db_instances(:db_instance_identifier=>@identifier)
         #puts "instances_result=" + instances_result.inspect
 
-        instances_result["DescribeDBInstancesResult"]["DBInstances"]["DBInstance"].each do |i|
-            puts "Trying to delete and getting i[DBInstanceStatus] -----------> " + i["DBInstanceStatus"]
-            assert i["DBInstanceStatus"] == "deleting"
+        instances.each do |i|
+            next unless i[:db_instance_identifier] == @identifier
+            db_status = i[:db_instance_status]
+            puts "Trying to delete and getting i[DBInstanceStatus] -----------> " + db_status
+            @rds.delete_db_instance(i[:db_instance_identifier]) if db_status == "available"
+            assert db_status == "deleting"
         end
+        sleep 2
 
-        assert instances_result["DescribeDBInstancesResult"]["DBInstances"]["DBInstance"].size < 2
     end
 
 
     def test_06_create_security_groups
         group_present=false
 
-        @rds.create_db_security_groups("new_sample_group", "new_sample_group_description")
+        @rds.create_db_security_group("new_sample_group", "new_sample_group_description")
 
-        @security_info = @rds.describe_db_security_groups({:force_array => ["DBSecurityGroup", "IPRange"]})["DescribeDBSecurityGroupsResult"]["DBSecurityGroups"]["DBSecurityGroup"]
+        security_groups = @rds.describe_db_security_groups
 
-        @security_info.each do |security_group|
-            if (security_group["DBSecurityGroupName"]=="new_sample_group")&&(security_group["DBSecurityGroupDescription"]=="new_sample_group_description")
+        security_groups.each do |security_group|
+            if (security_group[:db_security_group_name]=="new_sample_group")&&(security_group[:db_security_group_description]=="new_sample_group_description")
                 group_present = true
             end
         end
@@ -131,23 +144,22 @@ class TestRds < Test::Unit::TestCase
 
 
     def test_07_revoking_security_groups_ingress
-        sleep 15
+#        sleep 15
         @rds.revoke_db_security_group_ingress("default", "122.122.122.122/12")
         sleep 2
-        @security_info = @rds.describe_db_security_groups({:force_array => ["DBSecurityGroup", "IPRange"]})["DescribeDBSecurityGroupsResult"]["DBSecurityGroups"]["DBSecurityGroup"]
-        revoking = @security_info[0].inspect.include? "revoking"
+        security_groups = @rds.describe_db_security_groups
+        revoking = security_groups[0].inspect.include? "revoking"
         assert revoking
     end
 
 
-
     def test_08_delete_security_group
         group_present=false
         @rds.delete_db_security_group("new_sample_group")
         sleep 2
-        @security_info = @rds.describe_db_security_groups({:force_array => ["DBSecurityGroup", "IPRange"]})["DescribeDBSecurityGroupsResult"]["DBSecurityGroups"]["DBSecurityGroup"]
-        @security_info.each do |security_group|
-            if (security_group["DBSecurityGroupName"]=="new_sample_group")
+        security_groups = @rds.describe_db_security_groups
+        security_groups.each do |security_group|
+            if (security_group[:db_security_group_name]=="new_sample_group")
                 group_present=true
             end
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aws
 version: !ruby/object:Gem::Version 
-  version: 2.2.5
+  version: 2.2.6
 platform: ruby
 authors: 
 - Travis Reeder
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-13 00:00:00 -08:00
+date: 2010-02-15 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -55,6 +55,7 @@ extra_rdoc_files:
 files: 
 - lib/acf/right_acf_interface.rb
 - lib/aws.rb
+- lib/awsbase/aws_response_array.rb
 - lib/awsbase/benchmark_fix.rb
 - lib/awsbase/right_awsbase.rb
 - lib/awsbase/support.rb