amazon-ec2 0.6.2 → 0.7.0

data/README.rdoc

@@ -6,6 +6,12 @@ Amazon Web Services offers a compute power on demand capability known as the Ela
 
 This 'amazon-ec2' Ruby Gem is an interface library that can be used to interact with the Amazon EC2 system and control server resources on demand from your Ruby scripts, or from applications written in your Ruby framework of choice (Ruby on Rails, Merb, etc.).
 
+More recently, support has been added for the following EC2 related AWS API's as well:
+
+* Autoscaling
+* Cloudwatch
+* Elastic Load Balancing
+
 For the most complete and up-to date README information please visit the project homepage at:
 
 http://github.com/grempe/amazon-ec2/tree/master

data/VERSION

@@ -1 +1 @@
-0.6.2
+0.7.0

data/amazon-ec2.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{amazon-ec2}
-  s.version = "0.6.2"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Glenn Rempe"]
-  s.date = %q{2009-10-14}
+  s.date = %q{2009-10-29}
   s.description = %q{A Ruby library for accessing the Amazon Web Services Elastic Compute Cloud (EC2), Elastic Load Balancer (ELB), Cloudwatch, and Autoscaling API's.}
   s.email = %q{glenn@rempe.us}
   s.executables = ["ec2-gem-example.rb", "ec2-gem-profile.rb", "ec2sh", "setup.rb"]
@@ -53,6 +53,8 @@ Gem::Specification.new do |s|
      "lib/AWS/EC2/volumes.rb",
      "lib/AWS/ELB.rb",
      "lib/AWS/ELB/load_balancers.rb",
+     "lib/AWS/RDS.rb",
+     "lib/AWS/RDS/rds.rb",
      "lib/AWS/exceptions.rb",
      "lib/AWS/responses.rb",
      "perftools/ec2prof",
@@ -75,6 +77,7 @@ Gem::Specification.new do |s|
      "test/test_EC2_snapshots.rb",
      "test/test_EC2_volumes.rb",
      "test/test_ELB_load_balancers.rb",
+     "test/test_RDS.rb",
      "test/test_helper.rb",
      "wsdl/2007-08-29.ec2.wsdl",
      "wsdl/2008-02-01.ec2.wsdl",
@@ -104,7 +107,8 @@ Gem::Specification.new do |s|
      "test/test_EC2_snapshots.rb",
      "test/test_EC2_volumes.rb",
      "test/test_ELB_load_balancers.rb",
-     "test/test_helper.rb"
+     "test/test_helper.rb",
+     "test/test_RDS.rb"
   ]
 
   if s.respond_to? :specification_version then

data/bin/setup.rb

@@ -20,6 +20,7 @@ if ENV['AMAZON_ACCESS_KEY_ID'] && ENV['AMAZON_SECRET_ACCESS_KEY']
   @ec2 = AWS::EC2::Base.new(opts)
   @elb = AWS::ELB::Base.new(opts)
   @as = AWS::Autoscaling::Base.new(opts)
+  @rds = AWS::RDS::Base.new(opts)
 end
 
 puts "EC2 Server: #{opts[:server]}"

data/lib/AWS.rb

@@ -28,6 +28,14 @@ class Hash
       self[meth.to_s] || self[meth.to_sym]
     end
   end
+
+  def has?(key)
+    self[key] && !self[key].to_s.empty?
+  end
+
+  def does_not_have?(key)
+    self[key].nil? || self[key].to_s.empty?
+  end
 end
 
 
@@ -214,7 +222,7 @@ module AWS
           req['User-Agent'] = "github-amazon-ec2-ruby-gem"
 
           response = @http.request(req, query)
-          
+
           # Make a call to see if we need to throw an error based on the response given by EC2
           # All error classes are defined in EC2/exceptions.rb
           aws_error?(response)

data/lib/AWS/RDS.rb

@@ -0,0 +1,73 @@
+module AWS
+  module RDS
+
+    # Which host FQDN will we connect to for all API calls to AWS?
+    # If RDS_URL is defined in the users ENV we can override the default with that.
+    #
+    # @example
+    #   export RDS_URL='https://rds.amazonaws.com'
+    if ENV['RDS_URL']
+      RDS_URL = ENV['RDS_URL']
+      VALID_HOSTS = ['rds.amazonaws.com']
+      raise ArgumentError, "Invalid RDS_URL environment variable : #{RDS_URL}" unless VALID_HOSTS.include?(RDS_URL)
+      DEFAULT_HOST = URI.parse(RDS_URL).host
+    else
+      # Default US API endpoint
+      DEFAULT_HOST = 'rds.amazonaws.com'
+    end
+
+    API_VERSION = '2009-10-16'
+
+    class Base < AWS::Base
+      def api_version
+        API_VERSION
+      end
+
+      def default_host
+        DEFAULT_HOST
+      end
+
+      # Raises the appropriate error if the specified Net::HTTPResponse object
+      # contains an Amazon EC2 error; returns +false+ otherwise.
+      def aws_error?(response)
+
+        # return false if we got a HTTP 200 code,
+        # otherwise there is some type of error (40x,50x) and
+        # we should try to raise an appropriate exception
+        # from one of our exception classes defined in
+        # exceptions.rb
+        return false if response.is_a?(Net::HTTPSuccess)
+
+        # parse the XML document so we can walk through it
+        doc = REXML::Document.new(response.body)
+
+        # Check that the Error element is in the place we would expect.
+        # and if not raise a generic error exception
+        unless doc.root.elements[1].name == "Error"
+          raise Error, "Unexpected error format. response.body is: #{response.body}"
+        end
+
+        # An valid error response looks like this:
+        # <?xml version="1.0"?><Response><Errors><Error><Code>InvalidParameterCombination</Code><Message>Unknown parameter: foo</Message></Error></Errors><RequestID>291cef62-3e86-414b-900e-17246eccfae8</RequestID></Response>
+        # AWS EC2 throws some exception codes that look like Error.SubError.  Since we can't name classes this way
+        # we need to strip out the '.' in the error 'Code' and we name the error exceptions with this
+        # non '.' name as well.
+        error_code    = doc.root.elements['//ErrorResponse/Error/Code'].text.gsub('.', '')
+        error_message = doc.root.elements['//ErrorResponse/Error/Message'].text
+
+        # Raise one of our specific error classes if it exists.
+        # otherwise, throw a generic EC2 Error with a few details.
+        if AWS.const_defined?(error_code)
+          raise AWS.const_get(error_code), error_message
+        else
+          raise AWS::Error, error_message
+        end
+
+      end
+
+    end
+
+  end
+
+end
+

data/lib/AWS/RDS/rds.rb

@@ -0,0 +1,522 @@
+module AWS
+  module RDS
+    class Base < AWS::Base
+
+      # This API creates a new DB instance. Once the call has completed
+      # successfully, a new DB instance will be created, but it will not be
+      #
+      # @option options [String] :db_instance_identifier (nil) the name of the db_instance
+      # @option options [String] :allocated_storage in gigabytes (nil)
+      # @option options [String] :db_instance_class in contains compute and memory capacity (nil)
+      # @option options [String] :engine type i.e. MySQL5.1 (nil)
+      # @option options [String] :master_username is the master username for the db instance (nil)
+      # @option options [String] :master_user_password is the master password for the db instance (nil)
+      # @option options [String] :port is the port the database accepts connections on (3306)
+      # @option options [String] :db_name contains the name of the database to create when created (nil)
+      # @option options [String] :db_parameter_group is the database parameter group to associate with this instance (nil)
+      # @option options [String] :db_security_groups are the list of db security groups to associate with the instance (nil)
+      # @option options [String] :availability_zone is the availability_zone to create the instance in (nil)
+      # @option options [String] :preferred_maintenance_window in format: ddd:hh24:mi-ddd:hh24:mi (nil)
+      # @option options [String] :backend_retention_period is the number of days which automated backups are retained (1)
+      # @option options [String] :preferred_backup_window is the daily time range for which automated backups are created
+      #
+      def create_db_instance( options = {})
+        raise ArgumentError, "No :db_instance_identifier provided" if options.does_not_have?(:db_instance_identifier)
+        raise ArgumentError, "No :allocated_storage provided" if options.does_not_have?(:allocated_storage)
+        raise ArgumentError, "No :db_instance_class provided" if options.does_not_have?(:db_instance_class)
+        raise ArgumentError, "No :engine provided" if options.does_not_have?(:engine)
+        raise ArgumentError, "No :master_username provided" if options.does_not_have?(:master_username)
+        raise ArgumentError, "No :master_user_password provided" if options.does_not_have?(:master_user_password)
+        raise ArgumentError, "No :db_instance_class provided" if options.does_not_have?(:db_instance_class)
+
+        params = {}
+        params['DBInstanceIdentifier'] = options[:db_instance_identifier]
+        params["AllocatedStorage"] = options[:allocated_storage].to_s
+        params["DBInstanceClass"] = options[:db_instance_class]
+        params["Engine"] = options[:engine]
+        params["MasterUsername"] = options[:master_username]
+        params["MasterUserPassword"] = options[:master_user_password]
+
+        params["Port"] = options[:port].to_s if options.has?(:port)
+        params["DBName"] = options[:db_name] if options.has?(:db_name)
+        params["DBParameterGroup"] = options[:db_parameter_group] if options.has?(:db_parameter_group)
+        params["DBSecurityGroups"] = options[:db_security_groups] if options.has?(:db_security_groups)
+        params["AvailabilityZone"] = options[:availability_zone] if options.has?(:availability_zone)
+        params["PreferredMaintenanceWindow"] = options[:preferred_backup_window] if options.has?(:preferred_backup_window)
+        params["BackupRetentionPeriod"] = options[:backend_retention_period] if options.has?(:backend_retention_period)
+        params["PreferredBackupWindow"] = options[:preferred_backup_window] if options.has?(:preferred_backup_window)
+
+        return response_generator(:action => "CreateDBInstance", :params => params)
+      end
+
+      # This API method deletes a db instance identifier
+      #
+      # @option options [String] :db_instance_identifier is the instance identifier for the DB instance to be deleted (nil)
+      # @option options [String] :skip_final_snapshot determines to create a snapshot or not before it's deleted (no)
+      # @option options [String] :final_db_snapshot_identifier is the name of the snapshot created before the instance is deleted (name)
+      #
+      def delete_db_instance( options = {} )
+        raise ArgumentError, "No :db_instance_identifier provided" if options.does_not_have?(:db_instance_identifier)
+
+        params = {}
+        params['DBInstanceIdentifier'] = options[:db_instance_identifier]
+
+        params["SkipFinalSnapshot"] = options[:skip_final_snapshot].to_s if options.has?(:skip_final_snapshot)
+        params["FinalDBSnapshot­Identifier"] = options[:final_db_snapshot_identifier].to_s if options.has?(:final_db_snapshot_identifier)
+
+        return response_generator(:action => "DeleteDBInstance", :params => params)
+      end
+
+      # This API method creates a db parameter group
+      #
+      # @option options [String] :db_parameter_group_name is the name of the parameter group (nil)
+      # @option options [String] :engine is the engine the db parameter group can be used with (nil)
+      # @option options [String] :description is the description of the paramter group
+      #
+      def create_db_parameter_group( options = {} )
+        raise ArgumentError, "No :db_parameter_group_name provided" if options.does_not_have?(:db_parameter_group_name)
+        raise ArgumentError, "No :engine provided" if options.does_not_have?(:engine)
+        raise ArgumentError, "No :description provided" if options.does_not_have?(:description)
+
+        params = {}
+        params['DBParameterGroupName'] = options[:db_parameter_group_name]
+        params['Engine'] = options[:engine]
+        params['Description'] = options[:description]
+
+        return response_generator(:action => "CreateDBParameterGroup", :params => params)
+      end
+
+      # This API method creates a db security group
+      #
+      # @option options [String] :db_security_group_name is the name of the db security group (nil)
+      # @option options [String] :db_security_group_description is the description of the db security group
+      #
+      def create_db_security_group( options = {} )
+        raise ArgumentError, "No :db_security_group_name provided" if options.does_not_have?(:db_security_group_name)
+        raise ArgumentError, "No :db_security_group_description provided" if options.does_not_have?(:db_security_group_description)
+
+        params = {}
+        params['DBSecurityGroupName'] = options[:db_security_group_name]
+        params['DBSecurityGroupDescription'] = options[:db_security_group_description]
+
+        return response_generator(:action => "CreateDBSecurityGroup", :params => params)
+      end
+
+      # This API method creates a restoreable db snapshot
+      #
+      # @option options [String] :db_snapshot_identifier is the identifier of the db snapshot
+      # @option options [String] :db_instance_identifier is the identifier of the db instance
+      #
+      def create_db_snapshot( options = {} )
+        raise ArgumentError, "No :db_snapshot_identifier provided" if options.does_not_have?(:db_snapshot_identifier)
+        raise ArgumentError, "No :db_instance_identifier provided" if options.does_not_have?(:db_instance_identifier)
+
+        params = {}
+        params['DBSnapshotIdentifier'] = options[:db_snapshot_identifier]
+        params['DBInstanceIdentifier'] = options[:db_instance_identifier]
+
+        return response_generator(:action => "CreateDBSnapshot", :params => params)
+      end
+
+      # This API method authorizes network ingress for an amazon ec2 group
+      #
+      # @option options [String] :db_security_group_name is the name of the db security group
+      # @option options [String] :cidrip is the network ip to authorize
+      # @option options [String] :ec2_security_group_name is the name of the ec2 security group to authorize
+      # @option options [String] :ec2_security_group_owner_id is the owner id of the security group
+      #
+      def authorize_db_security_group( options = {} )
+        raise ArgumentError, "No :db_security_group_name provided" if options.does_not_have?(:db_security_group_name)
+
+        params = {}
+        params['DBSecurityGroupName'] = options[:db_security_group_name]
+
+        if options.has?(:cidrip)
+          params['CIDRIP'] = options[:cidrip]
+        elsif options.has?(:ec2_security_group_name) && options.has?(:ec2_security_group_owner_id)
+          params['EC2SecurityGroupName'] = options[:ec2_security_group_name]
+          params['EC2SecurityGroupOwnerId'] = options[:ec2_security_group_owner_id]
+        else
+          raise ArgumentError, "No :cidrip or :ec2_security_group_name and :ec2_security_group_owner_id provided"
+        end
+
+        return response_generator(:action => "AuthorizeDBSecurityGroupIngress", :params => params)
+      end
+
+      # This API method deletes a db paramter group
+      #
+      # @option options [String] :db_parameter_group_name is the name of the db paramter group to be deleted (nil)
+      #
+      def delete_db_parameter_group( options = {} )
+        raise ArgumentError, "No :db_parameter_group_name provided" if options.does_not_have?(:db_parameter_group_name)
+
+        params = {}
+        params['DBParameterGroupName'] = options[:db_parameter_group_name]
+
+        return response_generator(:action => "DeleteDBParameterGroup", :params => params)
+      end
+
+      # This API method deletes a db security group
+      #
+      # @option options [String] :db_parameter_group_name is the name of the db security group to be deleted (nil)
+      #
+      def delete_db_security_group( options = {} )
+        raise ArgumentError, "No :db_security_group_name provided" if options.does_not_have?(:db_security_group_name)
+
+        params = {}
+        params['DBSecurityGroupName'] = options[:db_security_group_name]
+
+        return response_generator(:action => "DeleteDBSecurityGroup", :params => params)
+      end
+
+      # This API method deletes a db snapshot
+      #
+      # @option options [String] :db_snapshot_identifier is the name of the db snapshot to be deleted (nil)
+      #
+      def delete_db_snapshot( options = {} )
+        raise ArgumentError, "No :db_snapshot_identifier provided" if options.does_not_have?(:db_snapshot_identifier)
+
+        params = {}
+        params['DBSnapshotIdentifier'] = options[:db_snapshot_identifier]
+
+        return response_generator(:action => "DeleteDBSnapshot", :params => params)
+      end
+
+      # This API method describes the db instances
+      #
+      # @option options [String] :db_instance_identifier if passed, only the description for the db instance matching this identifier is returned
+      # @option options [String] :max_records is the maximum number of records to include in the response
+      # @option options [String] :marker provided in the previous request
+      #
+      def describe_db_instances( options = {} )
+        params = {}
+        params['DBInstanceIdentifier'] = options[:db_instance_identifier] if options.has?(:db_instance_identifier)
+        params['MaxRecords'] = options[:max_records].to_s if options.has?(:max_records)
+        params['Marker'] = options[:marker] if options.has?(:marker)
+
+        return response_generator(:action => "DescribeDBInstances", :params => params)
+      end
+
+      # This API method describes the default engine parameters
+      #
+      # @option options [String] :engine is the name of the database engine
+      # @option options [String] :max_records is the maximum number of records to include in the response
+      # @option options [String] :marker provided in the previous request
+      #
+      def describe_engine_default_parameters( options = {} )
+        raise ArgumentError, "No :engine provided" if options.does_not_have?(:engine)
+
+        params = {}
+        params['Engine'] = options[:engine]
+        params['MaxRecords'] = options[:max_records].to_s if options.has?(:max_records)
+        params['Marker'] = options[:marker] if options.has?(:marker)
+
+        return response_generator(:action => "DescribeEngineDefaultParameters", :params => params)
+      end
+
+      # This API method returns information about all DB Parameter Groups for an account if no
+      # DB Parameter Group name is supplied, or displays information about a specific named DB Parameter Group.
+      # You can call this operation recursively using the Marker parameter.
+      #
+      # @option options [String] :db_parameter_group_name is the name of the parameter group
+      # @option options [String] :max_records is the maximum number of records to include in the response
+      # @option options [String] :marker provided in the previous request
+      #
+      def describe_db_parameter_groups( options = {} )
+        params = {}
+        params['DBParameterGroupName'] = options[:db_parameter_group_name] if options.has?(:db_parameter_group_name)
+        params['MaxRecords'] = options[:max_records].to_s if options.has?(:max_records)
+        params['Marker'] = options[:marker] if options.has?(:marker)
+
+        return response_generator(:action => "DescribeDBParameterGroups", :params => params)
+      end
+
+      # This API method returns information about parameters that are part of a parameter group.
+      # You can optionally request only parameters from a specific source.
+      # You can call this operation recursively using the Marker parameter.
+      #
+      # @option options [String] :db_parameter_group_name is the name parameter group
+      # @option options [String] :source is the type of parameter to return
+      # @option options [String] :max_records is the maximum number of records to include in the response
+      # @option options [String] :marker provided in the previous request
+      #
+      def describe_db_parameters( options = {} )
+        raise ArgumentError, "No :db_parameter_group_name provided" if options.does_not_have?(:db_parameter_group_name)
+
+        params = {}
+        params['DBParameterGroupName'] = options[:db_parameter_group_name]
+        params['Source'] = options[:source] if options.has?(:source)
+        params['MaxRecords'] = options[:max_records].to_s if options.has?(:max_records)
+        params['Marker'] = options[:marker] if options.has?(:marker)
+
+        return response_generator(:action => "DescribeDBParameters", :params => params)
+      end
+
+      # This API method returns all the DB Security Group details for a particular AWS account,
+      # or for a particular DB Security Group if a name is specified.
+      # You can call this operation recursively using the Marker parameter.
+      #
+      # @option options [String] :db_security_group_name is the name of the security group
+      # @option options [String] :max_records is the maximum number of records to include in the response
+      # @option options [String] :marker provided in the previous request
+      #
+      def describe_db_security_groups( options = {} )
+        params = {}
+        params['DBSecurityGroupName'] = options[:db_security_group_name] if options.has?(:db_security_group_name)
+        params['MaxRecords'] = options[:max_records].to_s if options.has?(:max_records)
+        params['Marker'] = options[:marker] if options.has?(:marker)
+
+        return response_generator(:action => "DescribeDBSecurityGroups", :params => params)
+      end
+
+      # This API method returns information about the DB Snapshots for this account.
+      # If you pass in a DBInstanceIdentifier, it returns information only about DB Snapshots taken for that DB Instance.
+      # If you pass in a DBSnapshotIdentifier,it will return information only about the specified snapshot.
+      # If you omit both DBInstanceIdentifier and DBSnapshotIdentifier, it returns all snapshot information for all
+      # database instances, up to the maximum number of records specified. Passing both DBInstanceIdentifier and
+      # DBSnapshotIdentifier results in an error.
+      #
+      # @option options [String] :db_instance_identifier is the unique identifier that identifies a DB instance
+      # @option options [String] :db_snapshot_identifier is a unique identifier for an amazon RDS snapshot
+      # @option options [String] :max_records is the maximum number of records to include in the response
+      # @option options [String] :marker provided in the previous request
+      #
+      def describe_db_snapshots( options = {} )
+        raise ArgumentError, "No :db_instance_identifier provided" if options.does_not_have?(:db_instance_identifier)
+
+        params = {}
+        params['DBInstanceIdentifier'] = options[:db_instance_identifier]
+
+        params['DBSnapshotIdentifier'] = options[:db_snapshot_identifier] if options.has?(:db_snapshot_identifier)
+        params['MaxRecords'] = options[:max_records].to_s if options.has?(:max_records)
+        params['Marker'] = options[:marker] if options.has?(:marker)
+
+        return response_generator(:action => "DescribeDBSnapshots", :params => params)
+      end
+
+      # This API method Returns information about events related to your DB Instances, DB Security Groups,
+      # and DB Parameter Groups for up to the past 14 days.
+      # You can get events specific to a particular DB Instance or DB Security Group by providing the name as a parameter.
+      # By default, the past hour of events are returned.
+      #
+      # If neither DBInstanceIdentifier or DBSecurityGroupName are provided,
+      # all events are be retrieved for DB Instances and DB Security Groups.
+      #
+      # @option options [String] :source_identifier is the identifier for the source for which events will be included
+      # @option options [String] :source_type is the type of event sources to return
+      # @option options [String] :start_time is the beginning of the time interval to return records for (ISO 8601 format)
+      # @option options [String] :end_time is the end of the time interval to return records (ISO 8601 format)
+      # @option options [String] :duration is the number of minutes to return events for.
+      # @option options [String] :max_records is the maximum number of records to include in the response
+      # @option options [String] :marker provided in the previous request
+      #
+      def describe_events( options = {} )
+        params = {}
+        params['SourceIdentifier'] = options[:source_identifier] if options.has?(:source_identifier)
+        params['SourceType'] = options[:source_type] if options.has?(:source_type)
+        params['StartTime'] = options[:start_time] if options.has?(:start_time)
+        params['EndTime'] = options[:end_time] if options.has?(:end_time)
+        params['Duration'] = options[:duration] if options.has?(:duration)
+        params['MaxRecords'] = options[:max_records].to_s if options.has?(:max_records)
+        params['Marker'] = options[:marker] if options.has?(:marker)
+
+        return response_generator(:action => "DescribeEvents", :params => params)
+      end
+
+      # This API changes the settings of an existing DB Instance.
+      #
+      # Changes are applied in the following manner: A ModifyDBInstance API call to modify security groups or to
+      # change the maintenance windows results in immediate action. Modification of the DB Parameter Group applies
+      # immediate parameters as soon as possible and pending-reboot parameters only when the RDS instance is rebooted.
+      # A request to scale the DB Instance class results puts the database instance into the modifying state.
+      #
+      # The DB Instance must be in available or modifying state for this API to accept changes.
+      #
+      # @option options [String] :db_instance_identifier (nil) the name of the db_instance
+      # @option options [String] :allocated_storage in gigabytes (nil)
+      # @option options [String] :db_instance_class in contains compute and memory capacity (nil)
+      # @option options [String] :engine type i.e. MySQL5.1 (nil)
+      # @option options [String] :master_username is the master username for the db instance (nil)
+      # @option options [String] :master_user_password is the master password for the db instance (nil)
+      # @option options [String] :port is the port the database accepts connections on (3306)
+      # @option options [String] :db_name contains the name of the database to create when created (nil)
+      # @option options [String] :db_parameter_group_name is the database parameter group to associate with this instance (nil)
+      # @option options [String] :db_security_groups are the list of db security groups to associate with the instance (nil)
+      # @option options [String] :availability_zone is the availability_zone to create the instance in (nil)
+      # @option options [String] :preferred_maintenance_window in format: ddd:hh24:mi-ddd:hh24:mi (nil)
+      # @option options [String] :backend_retention_period is the number of days which automated backups are retained (1)
+      # @option options [String] :preferred_backup_window is the daily time range for which automated backups are created
+      #
+      def modify_db_instance( options = {})
+        raise ArgumentError, "No :db_instance_identifier provided" if options.does_not_have?(:db_instance_identifier)
+
+        params = {}
+        params['DBInstanceIdentifier'] = options[:db_instance_identifier]
+
+        params["AllocatedStorage"] = options[:allocated_storage].to_s if options.has?(:allocated_storage)
+        params["DBInstanceClass"] = options[:db_instance_class] if options.has?(:db_instance_class)
+        params["Engine"] = options[:engine] if options.has?(:engine)
+        params["MasterUsername"] = options[:master_username] if options.has?(:master_username)
+        params["MasterUserPassword"] = options[:master_user_password] if options.has?(:master_user_password)
+        params["Port"] = options[:port].to_s if options.has?(:port)
+        params["DBName"] = options[:db_name] if options.has?(:db_name)
+        params["DBParameterGroupName"] = options[:db_parameter_group_name] if options.has?(:db_parameter_group_name)
+        params["DBSecurityGroups"] = options[:db_security_groups] if options.has?(:db_security_groups)
+        params["AvailabilityZone"] = options[:availability_zone] if options.has?(:availability_zone)
+        params["PreferredMaintenanceWindow"] = options[:preferred_backup_window] if options.has?(:preferred_backup_window)
+        params["BackupRetentionPeriod"] = options[:backend_retention_period] if options.has?(:backend_retention_period)
+        params["PreferredBackupWindow"] = options[:preferred_backup_window] if options.has?(:preferred_backup_window)
+
+        return response_generator(:action => "ModifyDBInstance", :params => params)
+      end
+
+      # This API method modifies the parameters of a DB Parameter Group.
+      # To modify more than one parameter, submit a list of the following: ParameterName, ParameterValue, and ApplyMethod.
+      # You can modify a maximum of 20 parameters in a single request.
+      #
+      # @option options [String] :db_parameter_group_name is the name of the parameter group to modify
+      # @option options [String] :parameters is the array of parameters to update in a hash format
+      #   {:name => "ParameterName", :value => "ParameterValue", :apply_method => "pending-reboot"}
+      #
+      def modify_db_parameter_group( options = {} )
+        raise ArgumentError, "No :db_parameter_group_name provided" if options.does_not_have?(:db_parameter_group_name)
+        raise ArgumentError, "No :parameters provided" if options.does_not_have?(:parameters)
+
+        params = {}
+        params['DBParameterGroupName'] = options[:db_parameter_group_name]
+        params.merge!(pathhashlist('Parameters.member', [options[:parameters]].flatten, {
+          :name => 'ParameterName',
+          :value => 'ParameterValue',
+          :apply_method => "ApplyMethod"
+        }))
+
+        return response_generator(:action => "ModifyDBParameterGroup", :params => params)
+      end
+
+      # This API method reboots a DB Instance.
+      # Once started, the process cannot be stopped, and the database instance will be unavailable until the reboot completes.
+      #
+      # @option options [String] :db_instance_identifier is the identifier for the db instance to restart
+      #
+      def reboot_db_instance( options = {} )
+        raise ArgumentError, "No :db_instance_identifier provided" if options.does_not_have?(:db_instance_identifier
+        )
+        params = {}
+        params['DBInstanceIdentifier'] = options[:db_instance_identifier] if options.has?(:db_instance_identifier)
+
+        return response_generator(:action => "RebootDBInstance", :params => params)
+      end
+
+      # This API method modifies the parameters of a DB Parameter Group.
+      # To modify more than one parameter, submit a list of the following: ParameterName, ParameterValue, and ApplyMethod.
+      # You can modify a maximum of 20 parameters in a single request.
+      #
+      # @option options [String] :db_parameter_group_name is the name of the parameter group to modify
+      # @option options [String] :reset_all_parameters specified whether to reset all the db parameters
+      # @option options [String] :parameters is the array of parameters to update in a hash format
+      #   {:name => "ParameterName", :apply_method => "pending-reboot"}
+      #
+      def reset_db_parameter_group( options = {} )
+        raise ArgumentError, "No :db_parameter_group_name provided" if options.does_not_have?(:db_parameter_group_name)
+        raise ArgumentError, "No :parameters provided" if options.does_not_have?(:parameters)
+
+        params = {}
+        params['DBParameterGroupName'] = options[:db_parameter_group_name]
+        params.merge!(pathhashlist('Parameters.member', [options[:parameters]].flatten, {
+          :name => 'ParameterName',
+          :apply_method => "ApplyMethod"
+        }))
+        params['ResetAllParameters'] = options[:reset_all_parameters] if options.has?(:reset_all_parameters)
+
+        return response_generator(:action => "ResetDBParameterGroup", :params => params)
+      end
+
+      # This API method restores a db instance to a snapshot of the instance
+      #
+      # @option options [String] :db_snapshot_identifier is the db identifier of the snapshot to restore from
+      # @option options [String] :db_instance_identifier is the identifier of the db instance
+      # @option options [String] :db_instance_class is the class of db compute and memory instance for the db instance
+      # @option options [String] :port is the port which the db can accept connections on
+      # @option options [String] :availability_zone is the EC2 zone which the db instance will be created
+      #
+      def restore_db_instance_from_snapshot( options = {} )
+        raise ArgumentError, "No :db_snapshot_identifier provided" if options.does_not_have?(:db_snapshot_identifier)
+        raise ArgumentError, "No :db_instance_identifier provided" if options.does_not_have?(:db_instance_identifier)
+        raise ArgumentError, "No :db_instance_class provided" if options.does_not_have?(:db_instance_class)
+
+        params = {}
+        params['DBSnapshotIdentifier'] = options[:db_snapshot_identifier]
+        params['DBInstanceIdentifier'] = options[:db_instance_identifier]
+        params['DBInstanceClass'] = options[:db_instance_class]
+
+        params['Port'] = options[:port].to_s if options.has?(:port)
+        params['AvailabilityZone'] = options[:availability_zone] if options.has?(:availability_zone)
+
+        return response_generator(:action => "RestoreDBInstanceFromDBSnapshot", :params => params)
+      end
+
+      # This API method restores a DB Instance to a specified time, creating a new DB Instance.
+      #
+      # Some characteristics of the new DB Instance can be modified using optional parameters.
+      # If these options are omitted, the new DB Instance defaults to the characteristics of the DB Instance from which the
+      # DB Snapshot was created.
+      #
+      # @option options [String] :source_db_instance_identifier the identifier of the source DB Instance from which to restore.
+      # @option options [String] :target_db_instance_identifier is the name of the new database instance to be created.
+      # @option options [String] :use_latest_restorable_time specifies that the db be restored to the latest restored time
+      # @option options [String] :restore_time specifies the date and time to restore from
+      # @option options [String] :db_instance_class specifies the class of the compute and memory of the EC2 instance
+      # @option options [String] :port is the port which the db can accept connections on
+      # @option options [String] :availability_zone is the EC2 zone which the db instance will be created
+      #
+      def restore_db_instance_to_point_in_time( options = {} )
+        raise ArgumentError, "No :db_snapshot_identifier provided" if options.does_not_have?(:db_snapshot_identifier)
+        raise ArgumentError, "No :db_instance_identifier provided" if options.does_not_have?(:db_instance_identifier)
+        raise ArgumentError, "No :db_instance_class provided" if options.does_not_have?(:db_instance_class)
+
+        params = {}
+        params['SourceDBInstanceIdentifier'] = options[:source_db_instance_identifier]
+        params['TargetDBInstanceIdentifier'] = options[:target_db_instance_identifier]
+
+        if options[:use_latest_restorable_time]
+          params['UseLatestRestorableTime'] = options[:use_latest_restorable_time]
+        elsif options[:restore_time]
+          params['RestoreTime'] = options[:restore_time]
+        end
+
+        params['DBInstanceClass'] = options[:db_instance_class] if options.has?(:db_instance_class)
+        params['Port'] = options[:port].to_s if options.has?(:port)
+        params['AvailabilityZone'] = options[:availability_zone] if options.has?(:availability_zone)
+
+        return response_generator(:action => "RestoreDBInstanceToPointInTime", :params => params)
+      end
+
+      # This API method authorizes network ingress for an amazon ec2 group
+      #
+      # @option options [String] :db_security_group_name is the name of the db security group
+      # @option options [String] :cidrip is the network ip to revoke
+      # @option options [String] :ec2_security_group_name is the name of the ec2 security group to authorize
+      # @option options [String] :ec2_security_group_owner_id is the owner id of the security group
+      #
+      def revoke_db_security_group( options = {} )
+        raise ArgumentError, "No :db_security_group_name provided" if options.does_not_have?(:db_security_group_name)
+
+        params = {}
+        params['DBSecurityGroupName'] = options[:db_security_group_name]
+
+        if options.has?(:cidrip)
+          params['CIDRIP'] = options[:cidrip]
+        elsif options.has?(:ec2_security_group_name) && options.has?(:ec2_security_group_owner_id)
+          params['EC2SecurityGroupName'] = options[:ec2_security_group_name]
+          params['EC2SecurityGroupOwnerId'] = options[:ec2_security_group_owner_id]
+        else
+          raise ArgumentError, "No :cidrip or :ec2_security_group_name and :ec2_security_group_owner_id provided"
+        end
+
+        return response_generator(:action => "RevokeDBSecurityGroupIngress", :params => params)
+      end
+
+    end
+  end
+end
+

data/test/test_RDS.rb

@@ -0,0 +1,354 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "rds databases " do
+  before do
+    @rds = AWS::RDS::Base.new( :access_key_id => "not a key", :secret_access_key => "not a secret" )
+
+    @create_db_instance_body = <<-RESPONSE
+    <CreateDBInstanceResponse xmlns="http://rds.amazonaws.com/admin/2009-10-16/">
+      <CreateDBInstanceResult>
+        <DBInstance>
+          <Engine>MySQL5.1</Engine>
+          <BackupRetentionPeriod>1</BackupRetentionPeriod>
+          <DBInstanceStatus>creating</DBInstanceStatus>
+          <DBInstanceIdentifier>mydbinstance</DBInstanceIdentifier>
+          <PreferredBackupWindow>03:00-05:00</PreferredBackupWindow>
+          <DBSecurityGroups>
+            <DBSecurityGroup>
+              <Status>active</Status>
+              <DBSecurityGroupName>default</DBSecurityGroupName>
+            </DBSecurityGroup>
+          </DBSecurityGroups>
+          <PreferredMaintenanceWindow>sun:05:00-sun:09:00</PreferredMaintenanceWindow>
+          <AllocatedStorage>10</AllocatedStorage>
+          <DBInstanceClass>db.m1.large</DBInstanceClass>
+          <MasterUsername>master</MasterUsername>
+        </DBInstance>
+      </CreateDBInstanceResult>
+      <ResponseMetadata>
+        <RequestId>e6fb58c5-bf34-11de-b88d-993294bf1c81</RequestId>
+      </ResponseMetadata>
+    </CreateDBInstanceResponse>
+    RESPONSE
+    @create_db_security_group = <<-RESPONSE
+    <CreateDBSecurityGroupResponse xmlns="http://rds.amazonaws.com/admin/2009-10-16/">
+      <CreateDBSecurityGroupResult>
+        <DBSecurityGroup>
+          <EC2SecurityGroups/>
+          <DBSecurityGroupDescription>My new DBSecurityGroup</DBSecurityGroupDescription>
+          <IPRanges/>
+          <OwnerId>621567473609</OwnerId>
+          <DBSecurityGroupName>mydbsecuritygroup4</DBSecurityGroupName>
+        </DBSecurityGroup>
+      </CreateDBSecurityGroupResult>
+      <ResponseMetadata>
+        <RequestId>c9cf9ff2-bf36-11de-b88d-993294bf1c81</RequestId>
+      </ResponseMetadata>
+    </CreateDBSecurityGroupResponse>
+    RESPONSE
+  end
+
+  specify "should be able to be create a db_instance" do
+    @rds.stubs(:make_request).with('CreateDBInstance', {'Engine' => 'MySQL5.1',
+        'MasterUsername' => 'master',
+        'DBInstanceClass' => 'db.m1.large',
+        'DBInstanceIdentifier' => 'testdb',
+        'AllocatedStorage' => '10',
+        'MasterUserPassword' => 'SecretPassword01'}).
+      returns stub(:body => @create_db_instance_body, :is_a? => true)
+    response = @rds.create_db_instance(
+      :db_instance_class => "db.m1.large",
+      :db_instance_identifier=>"testdb",
+      :allocated_storage => 10,
+      :engine => "MySQL5.1",
+      :master_user_password => "SecretPassword01",
+      :master_username => "master"
+      )
+    response.should.be.an.instance_of Hash
+
+    assert_equal response.CreateDBInstanceResult.DBInstance.AllocatedStorage, "10"
+  end
+
+  specify "should be able to create_db_security_group" do
+    @rds.stubs(:make_request).with('CreateDBSecurityGroup', {
+                      'DBSecurityGroupName' => 'mydbsecuritygroup',
+                      'DBSecurityGroupDescription' => 'My new DBSecurityGroup'}).
+      returns stub(:body => @create_db_security_group, :is_a? => true)
+    response = @rds.create_db_security_group(
+        :db_security_group_name => "mydbsecuritygroup",
+        :db_security_group_description => "My new DBSecurityGroup"
+      )
+    response.should.be.an.instance_of Hash
+
+    assert_equal response.CreateDBSecurityGroupResult.DBSecurityGroup.DBSecurityGroupName, "mydbsecuritygroup4"
+  end
+
+  specify "should be able to create_db_parameter_group" do
+    body =<<-EOE
+    <CreateDBParameterGroupResponse xmlns="http://rds.amazonaws.com/admin/2009-10-16/">
+      <CreateDBParameterGroupResult>
+        <DBParameterGroup>
+          <Engine>mysql5.1</Engine>
+          <Description>My new DBParameterGroup</Description>
+          <DBParameterGroupName>mydbparametergroup3</DBParameterGroupName>
+        </DBParameterGroup>
+      </CreateDBParameterGroupResult>
+      <ResponseMetadata>
+        <RequestId>0b447b66-bf36-11de-a88b-7b5b3d23b3a7</RequestId>
+      </ResponseMetadata>
+    </CreateDBParameterGroupResponse>
+    EOE
+    @rds.stubs(:make_request).with('CreateDBParameterGroup', {'Engine' => 'MySQL5.1',
+                                                  'DBParameterGroupName' => 'mydbsecuritygroup',
+                                                  'Description' => 'My test DBSecurity group'}).
+      returns stub(:body => body, :is_a? => true)
+    response = @rds.create_db_parameter_group(
+        :db_parameter_group_name => "mydbsecuritygroup",
+        :description => "My test DBSecurity group",
+        :engine => "MySQL5.1"
+      )
+    response.should.be.an.instance_of Hash
+
+    assert_equal response.CreateDBParameterGroupResult.DBParameterGroup.DBParameterGroupName, "mydbparametergroup3"
+  end
+
+  specify "should be able to create_db_snapshot" do
+    body =<<-EOE
+    <CreateDBSnapshotResponse xmlns="http://rds.amazonaws.com/admin/2009-10-16/">
+      <CreateDBSnapshotResult>
+        <DBSnapshot>
+          <Port>3306</Port>
+          <Status>creating</Status>
+          <Engine>mysql5.1</Engine>
+          <AvailabilityZone>us-east-1d</AvailabilityZone>
+          <InstanceCreateTime>2009-10-21T04:05:43.609Z</InstanceCreateTime>
+          <AllocatedStorage>50</AllocatedStorage>
+          <DBInstanceIdentifier>mynewdbinstance</DBInstanceIdentifier>
+          <MasterUsername>sa</MasterUsername>
+          <DBSnapshotIdentifier>mynewdbsnapshot3</DBSnapshotIdentifier>
+        </DBSnapshot>
+      </CreateDBSnapshotResult>
+      <ResponseMetadata>
+        <RequestId>48e870fd-bf38-11de-a88b-7b5b3d23b3a7</RequestId>
+      </ResponseMetadata>
+    </CreateDBSnapshotResponse>
+    EOE
+    @rds.stubs(:make_request).with('CreateDBSnapshot', {'DBSnapshotIdentifier' => 'mynewdbsnapshot3', 'DBInstanceIdentifier' => 'mynewdbinstance'}).
+      returns stub(:body => body, :is_a? => true)
+    response = @rds.create_db_snapshot(
+        :db_snapshot_identifier => "mynewdbsnapshot3",
+        :db_instance_identifier => "mynewdbinstance"
+      )
+    response.should.be.an.instance_of Hash
+
+    assert_equal response.CreateDBSnapshotResult.DBSnapshot.DBSnapshotIdentifier, "mynewdbsnapshot3"
+  end
+
+  specify "should be able to authorize_db_security_group" do
+    body =<<-EOE
+    <AuthorizeDBSecurityGroupIngressResponse xmlns="http://rds.amazonaws.com/admin/2009-10-16/">
+      <AuthorizeDBSecurityGroupIngressResult>
+        <DBSecurityGroup>
+          <EC2SecurityGroups/>
+          <DBSecurityGroupDescription>My new DBSecurityGroup</DBSecurityGroupDescription>
+          <IPRanges>
+            <IPRange>
+              <CIDRIP>192.168.1.1/24</CIDRIP>
+              <Status>authorizing</Status>
+            </IPRange>
+          </IPRanges>
+          <OwnerId>621567473609</OwnerId>
+          <DBSecurityGroupName>mydbsecuritygroup</DBSecurityGroupName>
+        </DBSecurityGroup>
+      </AuthorizeDBSecurityGroupIngressResult>
+      <ResponseMetadata>
+        <RequestId>d9799197-bf2d-11de-b88d-993294bf1c81</RequestId>
+      </ResponseMetadata>
+    </AuthorizeDBSecurityGroupIngressResponse>
+    EOE
+    @rds.stubs(:make_request).with('AuthorizeDBSecurityGroupIngress', {'CIDRIP' => '192.168.1.1/24', 'DBSecurityGroupName' => 'mydbsecuritygroup'}).
+      returns stub(:body => body, :is_a? => true)
+    response = @rds.authorize_db_security_group(
+        :db_security_group_name => "mydbsecuritygroup",
+        :cidrip => "192.168.1.1/24"
+      )
+    response.should.be.an.instance_of Hash
+
+    assert_equal response.AuthorizeDBSecurityGroupIngressResult.DBSecurityGroup.IPRanges.IPRange.CIDRIP, "192.168.1.1/24"
+  end
+
+  specify "should be able to delete_db_parameter_group" do
+    body =<<-EOE
+    <DeleteDBParameterGroupResponse xmlns="http://rds.amazonaws.com/admin/2009-10-16/">
+      <ResponseMetadata>
+        <RequestId>4dc38be9-bf3b-11de-a88b-7b5b3d23b3a7</RequestId>
+      </ResponseMetadata>
+    </DeleteDBParameterGroupResponse>
+    EOE
+    @rds.stubs(:make_request).with('DeleteDBParameterGroup', {'DBParameterGroupName' => 'mydbsecuritygroup'}).
+      returns stub(:body => body, :is_a? => true)
+    response = @rds.delete_db_parameter_group(
+        :db_parameter_group_name => "mydbsecuritygroup"
+      )
+    response.should.be.an.instance_of Hash
+  end
+
+  specify "should be able to delete_db_security_group" do
+    body =<<-EOE
+    <DeleteDBParameterGroupResponse xmlns="http://rds.amazonaws.com/admin/2009-10-16/">
+      <ResponseMetadata>
+        <RequestId>4dc38be9-bf3b-11de-a88b-7b5b3d23b3a7</RequestId>
+      </ResponseMetadata>
+    </DeleteDBParameterGroupResponse>
+    EOE
+    @rds.stubs(:make_request).with('DeleteDBSecurityGroup', {'DBSecurityGroupName' => 'mydbsecuritygroup'}).
+      returns stub(:body => body, :is_a? => true)
+    response = @rds.delete_db_security_group(
+        :db_security_group_name => "mydbsecuritygroup"
+      )
+    response.should.be.an.instance_of Hash
+  end
+
+  specify "should be able to delete_db_snapshot" do
+    body =<<-EOE
+    <DeleteDBParameterGroupResponse xmlns="http://rds.amazonaws.com/admin/2009-10-16/">
+      <ResponseMetadata>
+        <RequestId>4dc38be9-bf3b-11de-a88b-7b5b3d23b3a7</RequestId>
+      </ResponseMetadata>
+    </DeleteDBParameterGroupResponse>
+    EOE
+    @rds.stubs(:make_request).with('DeleteDBSnapshot', {'DBSnapshotIdentifier' => 'snapshotname'}).
+      returns stub(:body => body, :is_a? => true)
+    response = @rds.delete_db_snapshot(
+        :db_snapshot_identifier => "snapshotname"
+      )
+    response.should.be.an.instance_of Hash
+  end
+
+  specify "should be able to describe_db_instances" do
+    body =<<-EOE
+    <DescribeDBInstancesResponse xmlns="http://rds.amazonaws.com/admin/2009-10-16/">
+      <DescribeDBInstancesResult>
+        <DBInstances>
+          <DBInstance>
+            <LatestRestorableTime>2009-10-22T18:59:59Z</LatestRestorableTime>
+            <Engine>mysql5.1</Engine>
+            <BackupRetentionPeriod>3</BackupRetentionPeriod>
+            <DBInstanceStatus>available</DBInstanceStatus>
+            <DBParameterGroups>
+              <DBParameterGroup>
+                <ParameterApplyStatus>pending-reboot</ParameterApplyStatus>
+                <DBParameterGroupName>default.mysql5.1</DBParameterGroupName>
+              </DBParameterGroup>
+            </DBParameterGroups>
+            <Endpoint>
+              <Port>8443</Port>
+              <Address>dbinstancename.clouwupjnvmq.us-east-1-devo.rds.amazonaws.com</Address>
+            </Endpoint>
+            <DBInstanceIdentifier>dbinstancename</DBInstanceIdentifier>
+            <PreferredBackupWindow>03:00-05:00</PreferredBackupWindow>
+            <DBSecurityGroups>
+              <DBSecurityGroup>
+                <Status>active</Status>
+                <DBSecurityGroupName>default</DBSecurityGroupName>
+              </DBSecurityGroup>
+            </DBSecurityGroups>
+            <DBName>testdb</DBName>
+            <PreferredMaintenanceWindow>sun:05:00-sun:09:00</PreferredMaintenanceWindow>
+            <AvailabilityZone>us-east-1a</AvailabilityZone>
+            <InstanceCreateTime>2009-09-11T00:50:45.523Z</InstanceCreateTime>
+            <AllocatedStorage>20</AllocatedStorage>
+            <DBInstanceClass>db.m1.xlarge</DBInstanceClass>
+            <MasterUsername>sa</MasterUsername>
+          </DBInstance>
+        </DBInstances>
+      </DescribeDBInstancesResult>
+      <ResponseMetadata>
+        <RequestId>4f1fae46-bf3d-11de-a88b-7b5b3d23b3a7</RequestId>
+      </ResponseMetadata>
+    </DescribeDBInstancesResponse>
+    EOE
+    @rds.stubs(:make_request).with('DescribeDBInstances', {'MaxRecords' => '100'}).
+      returns stub(:body => body, :is_a? => true)
+    response = @rds.describe_db_instances(
+        :max_records => "100"
+      )
+    response.should.be.an.instance_of Hash
+  end
+
+  specify "should be able to describe_db_instances" do
+    body =<<-EOE
+    <DescribeEngineDefaultParametersResponse xmlns="http://rds.amazonaws.com/admin/2009-10-16/">
+      <DescribeEngineDefaultParametersResult>
+        <EngineDefaults>
+          <Engine>mysql5.1</Engine>
+          <Marker>bWF4X3VzZXJfY29ubmVjdGlvbnM=</Marker>
+          <Parameters>
+            <Parameter>
+              <DataType>boolean</DataType>
+              <Source>engine-default</Source>
+              <IsModifiable>true</IsModifiable>
+              <Description>Controls whether user-defined functions that have only an xxx symbol for the main function can be loaded</Description>
+              <ApplyType>static</ApplyType>
+              <AllowedValues>ON,OFF</AllowedValues>
+              <ParameterName>allow-suspicious-udfs</ParameterName>
+            </Parameter>
+            <Parameter>
+              <DataType>integer</DataType>
+              <Source>engine-default</Source>
+              <IsModifiable>true</IsModifiable>
+              <Description>Intended for use with master-to-master replication, and can be used to control the operation of AUTO_INCREMENT columns</Description>
+              <ApplyType>dynamic</ApplyType>
+              <AllowedValues>1-65535</AllowedValues>
+              <ParameterName>auto_increment_increment</ParameterName>
+            </Parameter>
+          </Parameters>
+        </EngineDefaults>
+      </DescribeEngineDefaultParametersResult>
+      <ResponseMetadata>
+        <RequestId>811f4032-bf3e-11de-b88d-993294bf1c81</RequestId>
+      </ResponseMetadata>
+    </DescribeEngineDefaultParametersResponse>
+    EOE
+    @rds.stubs(:make_request).with('DescribeEngineDefaultParameters', {'Engine' => 'MySQL5.1'}).
+      returns stub(:body => body, :is_a? => true)
+    response = @rds.describe_engine_default_parameters(
+        :engine => "MySQL5.1"
+      )
+    response.should.be.an.instance_of Hash
+  end
+
+  specify "should be able to describe_db_instances" do
+    body =<<-EOE
+    <ModifyDBParameterGroupResponse xmlns="http://rds.amazonaws.com/admin/2009-10-16/">
+      <ModifyDBParameterGroupResult>
+        <DBParameterGroupName>mydbparametergroup</DBParameterGroupName>
+      </ModifyDBParameterGroupResult>
+      <ResponseMetadata>
+        <RequestId>5ba91f97-bf51-11de-bf60-ef2e377db6f3</RequestId>
+      </ResponseMetadata>
+    </ModifyDBParameterGroupResponse>
+    EOE
+
+    @rds.stubs(:make_request).with('ModifyDBParameterGroup', {
+        'DBParameterGroupName' => 'mytestdb',
+        'Parameters.member.1.ParameterName' => 'max_user_connections',
+        'Parameters.member.1.ParameterValue' => '24',
+        'Parameters.member.1.ApplyMethod' => 'pending-reboot',
+        'Parameters.member.2.ParameterName' => 'max_allowed_packet',
+        'Parameters.member.2.ParameterValue' => '1024',
+        'Parameters.member.2.ApplyMethod' => 'immediate',
+        }).
+      returns stub(:body => body, :is_a? => true)
+    response = @rds.modify_db_parameter_group(
+        :db_parameter_group_name => "mytestdb",
+        :parameters => [
+          {:name => "max_user_connections", :value => "24", :apply_method => "pending-reboot"},
+          {:name => "max_allowed_packet", :value => "1024", :apply_method => "immediate"}
+        ]
+      )
+    response.should.be.an.instance_of Hash
+  end
+
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: amazon-ec2
 version: !ruby/object:Gem::Version 
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors: 
 - Glenn Rempe
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-14 00:00:00 -07:00
+date: 2009-10-29 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -110,6 +110,8 @@ files:
 - lib/AWS/EC2/volumes.rb
 - lib/AWS/ELB.rb
 - lib/AWS/ELB/load_balancers.rb
+- lib/AWS/RDS.rb
+- lib/AWS/RDS/rds.rb
 - lib/AWS/exceptions.rb
 - lib/AWS/responses.rb
 - perftools/ec2prof
@@ -132,6 +134,7 @@ files:
 - test/test_EC2_snapshots.rb
 - test/test_EC2_volumes.rb
 - test/test_ELB_load_balancers.rb
+- test/test_RDS.rb
 - test/test_helper.rb
 - wsdl/2007-08-29.ec2.wsdl
 - wsdl/2008-02-01.ec2.wsdl
@@ -187,3 +190,4 @@ test_files:
 - test/test_EC2_volumes.rb
 - test/test_ELB_load_balancers.rb
 - test/test_helper.rb
+- test/test_RDS.rb