icehouse-right_aws 1.11.0 → 2.2.0

data/lib/iam/right_iam_mfa_devices.rb

@@ -0,0 +1,67 @@
+module RightAws
+
+  class IamInterface < RightAwsBase
+
+    #-----------------------------------------------------------------
+    #      MFADevices
+    #-----------------------------------------------------------------
+
+    # Lists the MFA devices associated with the specified User name.
+    #
+    # Options: :user_name, :max_items, :marker
+    #
+    def list_mfa_devices(options={}, &block)
+      incrementally_list_iam_resources('ListMFADevices', options, &block)
+    end
+
+    # Enables the specified MFA device and associates it with the specified User name.
+    # Once enabled, the MFA device is required for every subsequent login by the User name associated with the device.
+    #
+    #  iam.enable_mfa_device('kd1', 'x12345', '12345', '67890') #=> true
+    #
+    def enable_mfa_device(user_name, serial_number, auth_code1, auth_code2)
+      request_hash = { 'UserName'            => user_name,
+                       'SerialNumber'        => serial_number,
+                       'AuthenticationCode1' => auth_code1,
+                       'AuthenticationCode2' => auth_code2 }
+      link = generate_request("EnableMFADevice", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    # Synchronizes the specified MFA device with AWS servers.
+    #
+    #  iam.resync_mfa_device('kd1', 'x12345', '12345', '67890') #=> true
+    #
+    def resync_mfa_device(user_name, serial_number, auth_code1, auth_code2)
+      request_hash = { 'UserName'            => user_name,
+                       'SerialNumber'        => serial_number,
+                       'AuthenticationCode1' => auth_code1,
+                       'AuthenticationCode2' => auth_code2 }
+      link = generate_request("ResyncMFADevice", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    # Deactivates the specified MFA device and removes it from association with the User name for which it was originally enabled.
+    #
+    #  deactivate_mfa_device('kd1', 'dev1234567890') #=> true
+    #
+    def deactivate_mfa_device(user_name, serial_number)
+      request_hash = { 'UserName'     => user_name,
+                       'SerialNumber' => serial_number }
+      link = generate_request("DeactivateMFADevice", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    #-----------------------------------------------------------------
+    #      PARSERS
+    #-----------------------------------------------------------------
+
+    class ListMFADevicesParser < BasicIamListParser #:nodoc:
+      def reset
+        @expected_tags = %w{ SerialNumber UserName }
+      end
+    end
+
+  end
+
+end

data/lib/iam/right_iam_users.rb

@@ -0,0 +1,251 @@
+module RightAws
+
+  class IamInterface < RightAwsBase
+
+    #-----------------------------------------------------------------
+    #      Users
+    #-----------------------------------------------------------------
+
+    # Lists the Users that have the specified path prefix.
+    #
+    # Options: :path_prefix, :max_items, :marker
+    #
+    #  iam.list_users #=>
+    #    [{:user_name=>"kd",
+    #      :user_id=>"AI000000000000000006A",
+    #      :arn=>"arn:aws:iam::640000000037:user/kd",
+    #      :path=>"/"}]
+    #
+    def list_users(options={}, &block)
+      incrementally_list_iam_resources('ListUsers', options, &block)
+    end
+
+    # Creates a new User for your AWS Account.
+    #
+    # Options: :path
+    #
+    #  iam.create_user('kd') #=>
+    #    {:user_name=>"kd",
+    #     :user_id=>"AI000000000000000006A",
+    #     :arn=>"arn:aws:iam::640000000037:user/kd",
+    #     :path=>"/"}
+    #
+    def create_user(user_name, options={})
+      request_hash = { 'UserName' => user_name }
+      request_hash['Path'] = options[:path] unless options[:path]
+      link = generate_request("CreateUser", request_hash)
+      request_info(link, GetUserParser.new(:logger => @logger))
+    end
+
+    # Updates the name and/or the path of the specified User.
+    #
+    #  iam.update_user('kd1', :new_user_name => 'kd1', :new_path => '/kd1/') #=> true
+    #
+    def update_user(user_name, options={})
+      request_hash = { 'UserName' => user_name}
+      request_hash['NewUserName'] = options[:new_user_name] unless options[:new_user_name].right_blank?
+      request_hash['NewPath']     = options[:new_path]       unless options[:new_path].right_blank?
+      link = generate_request("UpdateUser", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    # Retrieves information about the specified User, including the User's path, GUID, and ARN.
+    #
+    #  iam.get_user('kd') #=>
+    #    {:user_name=>"kd",
+    #     :user_id=>"AI000000000000000006A",
+    #     :arn=>"arn:aws:iam::640000000037:user/kd",
+    #     :path=>"/"}
+    #
+    def get_user(user_name)
+      request_hash = { 'UserName' => user_name }
+      link = generate_request("GetUser", request_hash)
+      request_info(link, GetUserParser.new(:logger => @logger))
+    end
+
+    # Deletes the specified User. The User must not belong to any groups, have any keys or signing certificates, or have any attached policies.
+    #
+    #  iam.delete_user('kd') #=> true
+    #
+    def delete_user(user_name)
+      request_hash = { 'UserName' => user_name }
+      link = generate_request("DeleteUser", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    #-----------------------------------------------------------------
+    #      User Policies
+    #-----------------------------------------------------------------
+
+    # Lists the names of the policies associated with the specified User.
+    #
+    # Options: :max_items, :marker
+    #
+    #  iam.list_user_policies('kd') #=> ["kd_user_policy_1"]
+    #
+    def list_user_policies(user_name, options={}, &block)
+      options[:user_name] = user_name
+      incrementally_list_iam_resources('ListUserPolicies', options, :parser => BasicIamListParser, &block)
+    end
+
+    # Adds (or updates) a policy document associated with the specified User
+    #
+    #  iam.put_user_policy('kd', 'kd_user_policy_1', %Q({"Statement":[{"Effect":"Allow","Action":"*","Resource":"*"}]})) #=> true
+    #
+    def put_user_policy(user_name, policy_name, policy_document)
+      request_hash = { 'UserName'       => user_name,
+                       'PolicyDocument' => policy_document,
+                       'PolicyName'     => policy_name }
+      link = generate_request_impl(:post, "PutUserPolicy", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    # Retrieves the specified policy document for the specified User.
+    #
+    #  iam.get_user_policy('kd','kd_user_policy_1') #=>
+    #    {:user_name=>"kd",
+    #     :policy_name=>"kd_user_policy_1",
+    #     :policy_document=>"{\"Statement\":[{\"Effect\":\"Allow\",\"Action\":\"*\",\"Resource\":\"*\"}]}"}
+    #
+    def get_user_policy(user_name, policy_name)
+      request_hash = { 'UserName'   => user_name,
+                       'PolicyName' => policy_name }
+      link = generate_request("GetUserPolicy", request_hash)
+      result = request_info(link, GetUserPolicyParser.new(:logger => @logger))
+      result[:policy_document] = URI::decode(result[:policy_document])
+      result
+    end
+
+    # Deletes the specified policy associated with the specified User.
+    #
+    #  iam.delete_user_policy('kd','kd_user_policy_1') #=> true
+    #
+    def delete_user_policy(user_name, policy_name)
+      request_hash = { 'UserName'   => user_name,
+                       'PolicyName' => policy_name }
+      link = generate_request("DeleteUserPolicy", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    #-----------------------------------------------------------------
+    #      User Groups
+    #-----------------------------------------------------------------
+
+    # Lists the names of the policies associated with the specified group. If there are none,
+    # the action returns an empty list.
+    #
+    # Options: :max_items, :marker
+    #
+    #  iam.list_groups_for_user('kd') #=>
+    #    [{:group_name=>"kd_test_1",
+    #      :group_id=>"AGP000000000000000UTY",
+    #      :arn=>"arn:aws:iam::640000000037:group/kd1/kd_test_1",
+    #      :path=>"/kd1/"}]
+    #
+    def list_groups_for_user(user_name, options={}, &block)
+      options[:user_name] = user_name
+      incrementally_list_iam_resources('ListGroupsForUser', options, :parser => ListGroupsParser, &block)
+    end
+
+    # Adds the specified User to the specified group.
+    #
+    #  iam.add_user_to_group('kd', 'kd_test_1') #=> true
+    #
+    def add_user_to_group(user_name, group_name)
+      request_hash = { 'UserName'  => user_name,
+                       'GroupName' => group_name }
+      link = generate_request("AddUserToGroup", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    # Removes the specified User from the specified group.
+    #
+    #  iam.remove_user_from_group('kd', 'kd_test_1') #=> true
+    #
+    def remove_user_from_group(user_name, group_name)
+      request_hash = { 'UserName'  => user_name,
+                       'GroupName' => group_name }
+      link = generate_request("RemoveUserFromGroup", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    #-----------------------------------------------------------------
+    #      User Login Profiles
+    #-----------------------------------------------------------------
+
+    # Creates a login profile for the specified User, giving the User the ability to access
+    # AWS services such as the AWS Management Console.
+    #
+    #  iam.create_login_profile('kd','q1w2e3r4t5') #=> { :user_name => 'kd' }
+    #
+    def create_login_profile(user_name, password)
+      request_hash = { 'UserName' => user_name,
+                       'Password' => password}
+      link = generate_request("CreateLoginProfile", request_hash)
+      request_info(link, GetLoginProfileParser.new(:logger => @logger))
+    end
+
+    # Updates the login profile for the specified User. Use this API to change the User's password.
+    #
+    #  update_login_profile('kd', '00000000') #=> true
+    #
+    def update_login_profile(user_name, options={})
+      request_hash = { 'UserName' => user_name}
+      request_hash['Password'] = options[:password] unless options[:passwrod].right_blank?
+      link = generate_request("UpdateLoginProfile", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    # Retrieves the login profile for the specified User
+    #
+    #  iam.create_login_profile('kd','q1w2e3r4t5') #=> { :user_name => 'kd' }
+    #
+    def get_login_profile(user_name)
+      request_hash = { 'UserName' => user_name }
+      link = generate_request("GetLoginProfile", request_hash)
+      request_info(link, GetLoginProfileParser.new(:logger => @logger))
+    end
+
+    # Deletes the login profile for the specified User, which terminates the User's ability to access
+    # AWS services through the IAM login page.
+    #
+    #  iam.delete_login_profile('kd') #=> true
+    #
+    def delete_login_profile(user_name)
+      request_hash = { 'UserName' => user_name }
+      link = generate_request("DeleteLoginProfile", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    #-----------------------------------------------------------------
+    #      PARSERS
+    #-----------------------------------------------------------------
+
+    class ListUsersParser < BasicIamListParser #:nodoc:
+      def reset
+        @expected_tags = %w{ Arn Path UserId UserName }
+      end
+    end
+
+    class GetUserParser < BasicIamParser #:nodoc:
+      def reset
+        @expected_tags = %w{ Arn Path UserId UserName }
+      end
+    end
+
+    class GetUserPolicyParser < BasicIamParser #:nodoc:
+      def reset
+        @expected_tags = %w{ PolicyDocument PolicyName UserName }
+      end
+    end
+
+    class GetLoginProfileParser < BasicIamParser #:nodoc:
+      def reset
+        @expected_tags = %w{ UserName }
+      end
+    end
+
+  end
+
+end
+

data/lib/rds/right_rds_interface.rb

@@ -27,14 +27,15 @@ module RightAws
     
     include RightAwsBaseInterface
 
-    API_VERSION      = "2009-10-16"
+    API_VERSION      = "2011-04-01"
     DEFAULT_HOST     = 'rds.amazonaws.com'
     DEFAULT_PORT     = 443
     DEFAULT_PROTOCOL = 'https'
     DEFAULT_PATH     = '/'
 
     DEFAULT_INSTANCE_CLASS   =  'db.m1.small'
-    INSTANCE_CLASSES         = ['db.m1.small', 'db.m1.large', 'db.m1.xlarge', 'db.m2.2xlarge', 'db.m2.4xlarge']
+    INSTANCE_CLASSES         = ['db.m1.small', 'db.m1.large', 'db.m1.xlarge', 'db.m2.2xlarge', 'db.m2.2xlarge', 'db.m2.4xlarge']
+    LICENSE_MODELS           = ['bring-your-own-license', 'license-included', 'general-public-license']
 
     @@bench = AwsBenchmarkingBlock.new
     def self.bench_xml
@@ -51,7 +52,6 @@ module RightAws
     # * <tt>:server</tt>: RDS service host, default: DEFAULT_HOST
     # * <tt>:port</tt>: RDS service port, default: DEFAULT_PORT
     # * <tt>:protocol</tt>: 'http' or 'https', default: DEFAULT_PROTOCOL
-    # * <tt>:multi_thread</tt>: true=HTTP connection per thread, false=per process
     # * <tt>:logger</tt>: for log messages, default: RAILS_DEFAULT_LOGGER else STDOUT
     #
     #  rds = RightAws::RdsInterface.new('xxxxxxxxxxxxxxxxxxxxx','xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',
@@ -94,7 +94,7 @@ module RightAws
         link = generate_request(action, params)
         last_response = request_info( link,  parser_class.new(:logger => @logger))
         params['Marker'] = last_response[:marker]
-        break unless block && block.call(last_response) && !last_response[:marker].blank?
+        break unless block && block.call(last_response) && !last_response[:marker].right_blank?
       end
       last_response
     end
@@ -113,20 +113,23 @@ module RightAws
     #
     #  # Get a list of DB instances. The response is an +Array+ of instances.
     #  rds.describe_db_instances #=>
-    #    [{:instance_class=>"Medium",
+    #    [{:instance_class=>"db.m1.small",
     #      :status=>"creating",
-    #      :engine=>"MySQL5.1",
-    #      :allocated_storage=>50,
-    #      :pending_modified_values=>{},
-    #      :db_parameter_group=>{:status=>"in-sync", :name=>"default.MySQL5.1"},
-    #      :db_security_groups=>
-    #       [{:status=>"active", :name=>"kd-2-test"},
-    #        {:status=>"active", :name=>"default"},
-    #        {:status=>"active", :name=>"kd-1-test"}],
-    #      :availability_zone=>"us-east-1b",
+    #      :backup_retention_period=>1,
+    #      :read_replica_db_instance_identifiers=>["kd-delete-me-01-replica-01"],
     #      :master_username=>"username",
-    #      :aws_id=>"kd-my-awesome-db-2",
-    #      :preferred_maintenance_window=>"Sun:05:00-Sun:09:00"}]
+    #      :preferred_maintenance_window=>"sun:05:00-sun:09:00",
+    #      :db_parameter_group=>{:status=>"in-sync", :name=>"default.mysql5.1"},
+    #      :multi_az=>true,
+    #      :engine=>"mysql",
+    #      :auto_minor_version_upgrade=>false,
+    #      :allocated_storage=>25,
+    #      :availability_zone=>"us-east-1d",
+    #      :aws_id=>"kd-delete-me-01",
+    #      :preferred_backup_window=>"03:00-05:00",
+    #      :engine_version=>"5.1.50",
+    #      :pending_modified_values=>{:master_user_password=>"****"},
+    #      :db_security_groups=>[{:status=>"active", :name=>"default"}]}]
     #
     #  # Retrieve a custom DB instance.
     #  # The response is an +Array+ with a single instance record.
@@ -136,27 +139,30 @@ module RightAws
     #  rds.describe_db_instances(:max_records => 30) do |x|
     #    puts x.inspect #=>
     #      {:db_instances=>
-    #        [{:instance_class=>"Medium",
+    #        [{:instance_class=>"db.m1.small",
     #          :status=>"creating",
-    #          :engine=>"MySQL5.1",
-    #          :allocated_storage=>50,
-    #          :pending_modified_values=>{},
-    #          :db_parameter_group=>{:status=>"in-sync", :name=>"default.MySQL5.1"},
-    #          :db_security_groups=>
-    #           [{:status=>"active", :name=>"kd-2-test"},
-    #            {:status=>"active", :name=>"default"},
-    #            {:status=>"active", :name=>"kd-1-test"}],
-    #          :availability_zone=>"us-east-1b",
+    #          :backup_retention_period=>1,
+    #          :read_replica_db_instance_identifiers=>["kd-delete-me-01-replica-01"],
     #          :master_username=>"username",
-    #          :aws_id=>"kd-my-awesome-db-2",
-    #          :preferred_maintenance_window=>"Sun:05:00-Sun:09:00"}]}
+    #          :preferred_maintenance_window=>"sun:05:00-sun:09:00",
+    #          :db_parameter_group=>{:status=>"in-sync", :name=>"default.mysql5.1"},
+    #          :multi_az=>true,
+    #          :engine=>"mysql",
+    #          :auto_minor_version_upgrade=>false,
+    #          :allocated_storage=>25,
+    #          :availability_zone=>"us-east-1d",
+    #          :aws_id=>"kd-delete-me-01",
+    #          :preferred_backup_window=>"03:00-05:00",
+    #          :engine_version=>"5.1.50",
+    #          :pending_modified_values=>{:master_user_password=>"****"},
+    #          :db_security_groups=>[{:status=>"active", :name=>"default"}]}]}
     #    true
     #  end
     #
-    def describe_db_instances(params={}, &block)
+    def describe_db_instances(*params, &block)
       item, params = AwsUtils::split_items_and_params(params)
       params = params.dup
-      params['DBInstanceIdentifier'] = item if item
+      params['DBInstanceIdentifier'] = item.first unless item.right_blank?
       result = []
       incrementally_list_items('DescribeDBInstances', DescribeDbInstancesParser, params) do |response|
         result += response[:db_instances]
@@ -168,24 +174,31 @@ module RightAws
     # Create a new RDS instance of the type and size specified by you. The default storage engine for RDS Instances is InnoDB.
     #
     # Mandatory arguments: +aws_id+, +master_username+, +master_user_password+
-    # Optional params: +:allocated_storage+ (25 by def), +:instance_class+, +:engine+ ('MySQL5.1' by def),
+    # Optional params: +:allocated_storage+ (25 by def), +:instance_class+, +:engine+ ('MySQL' by def),
     # +:endpoint_port+, +:db_name+, +:db_security_groups+, +:db_parameter_group+,  +:availability_zone+, +:preferred_maintenance_window+
-    # +:backup_retention_period+, +:preferred_backup_window+
+    # +:backup_retention_period+, +:preferred_backup_window+, +:multi_az+, +:engine_version+, +:auto_minor_version_upgrade+,
+    # +:license_model+
     #
-    #  ds.create_db_instance('my-awesome-db', 'username', 'password') #=>
-    #    {:instance_class=>"Medium",
-    #     :status=>"creating",
-    #     :engine=>"MySQL5.1",
-    #     :allocated_storage=>50,
-    #     :pending_modified_values=>{},
-    #     :db_security_groups=>
-    #      [{:status=>"active", :name=>"kd-2-test"},
-    #       {:status=>"active", :name=>"default"},
-    #       {:status=>"active", :name=>"kd-1-test"}],
-    #     :availability_zone=>"us-east-1b",
-    #     :master_username=>"username",
-    #     :aws_id=>"kd-my-awesome-db-2",
-    #     :preferred_maintenance_window=>"Sun:05:00-Sun:09:00"}
+    #   rds.create_db_instance('kd-delete-me-01', 'username', 'password',
+    #                           :instance_class    => 'db.m1.small',
+    #                           :multi_az          => true,
+    #                           :auto_minor_version_upgrade => false ) #=>
+    #    {:instance_class=>"db.m1.small",
+    #      :multi_az=>true,
+    #      :status=>"creating",
+    #      :backup_retention_period=>1,
+    #      :read_replica_db_instance_identifiers=>[],
+    #      :master_username=>"username",
+    #      :preferred_maintenance_window=>"sun:05:00-sun:09:00",
+    #      :auto_minor_version_upgrade=>false,
+    #      :db_parameter_group=>{:status=>"in-sync", :name=>"default.mysql5.1"},
+    #      :engine=>"mysql",
+    #      :allocated_storage=>25,
+    #      :aws_id=>"kd-delete-me-01",
+    #      :preferred_backup_window=>"03:00-05:00",
+    #      :engine_version=>"5.1.50",
+    #      :pending_modified_values=>{:master_user_password=>"****"},
+    #      :db_security_groups=>[{:status=>"active", :name=>"default"}]}
     #
     def create_db_instance(aws_id, master_username, master_user_password, params={})
       request_hash = {}
@@ -194,19 +207,22 @@ module RightAws
       request_hash['MasterUsername']       = master_username
       request_hash['MasterUserPassword']   = master_user_password
       # Mandatory with default values
-      request_hash['DBInstanceClass']  = params[:instance_class].blank?    ? DEFAULT_INSTANCE_CLASS : params[:instance_class].to_s
-      request_hash['AllocatedStorage'] = params[:allocated_storage].blank? ? 25            : params[:allocated_storage]
-      request_hash['Engine']           = params[:engine].blank?            ? 'MySQL5.1'    : params[:engine]
+      request_hash['DBInstanceClass']            = params[:instance_class].right_blank?    ? DEFAULT_INSTANCE_CLASS : params[:instance_class].to_s
+      request_hash['AllocatedStorage']           = params[:allocated_storage].right_blank? ? 25                     : params[:allocated_storage]
+      request_hash['Engine']                     = params[:engine].right_blank?            ? 'mysql'                : params[:engine]
       # Optional
-      request_hash['EndpointPort']               = params[:endpoint_port]                unless params[:endpoint_port].blank?
-      request_hash['DBName']                     = params[:db_name]                      unless params[:db_name].blank?
-      request_hash['AvailabilityZone']           = params[:availability_zone]            unless params[:availability_zone].blank?
-      request_hash['PreferredMaintenanceWindow'] = params[:preferred_maintenance_window] unless params[:preferred_maintenance_window].blank?
-      request_hash['BackupRetentionPeriod']      = params[:backup_retention_period]      unless params[:backup_retention_period].blank?
-      request_hash['PreferredBackupWindow']      = params[:preferred_backup_window]      unless params[:preferred_backup_window].blank?
+      request_hash['Port']                       = params[:endpoint_port]                   unless params[:endpoint_port].right_blank?
+      request_hash['DBName']                     = params[:db_name]                         unless params[:db_name].right_blank?
+      request_hash['AvailabilityZone']           = params[:availability_zone]               unless params[:availability_zone].right_blank?
+      request_hash['MultiAZ']                    = params[:multi_az].to_s                   unless params[:multi_az].nil?
+      request_hash['PreferredMaintenanceWindow'] = params[:preferred_maintenance_window]    unless params[:preferred_maintenance_window].right_blank?
+      request_hash['BackupRetentionPeriod']      = params[:backup_retention_period]         unless params[:backup_retention_period].right_blank?
+      request_hash['PreferredBackupWindow']      = params[:preferred_backup_window]         unless params[:preferred_backup_window].right_blank?
+      request_hash['DBParameterGroupName']       = params[:db_parameter_group]              unless params[:db_parameter_group].right_blank?
+      request_hash['EngineVersion']              = params[:engine_version]                  unless params[:engine_version].right_blank?
+      request_hash['AutoMinorVersionUpgrade']    = params[:auto_minor_version_upgrade].to_s unless params[:auto_minor_version_upgrade].nil?
+      request_hash['LicenseModel']               = params[:license_model]                   unless params[:license_model].right_blank?
       request_hash.merge!(amazonize_list('DBSecurityGroups.member',  params[:db_security_groups]))
-#      request_hash.merge!(amazonize_list('DBParameterGroups.member', params[:db_parameter_groups]))
-      request_hash['DBParameterGroup']           = params[:db_parameter_group]           unless params[:db_parameter_group].blank?
       link = generate_request('CreateDBInstance', request_hash)
       request_info(link, DescribeDbInstancesParser.new(:logger => @logger))[:db_instances].first
     end
@@ -216,23 +232,60 @@ module RightAws
     # Mandatory arguments: +aws_id+. 
     # Optional params: +:master_user_password+, +:instance_class+, +:db_security_groups+,
     # +:db_parameter_group+, +:preferred_maintenance_window+, +:allocated_storage+, +:apply_immediately+,
-    # +:backup_retention_period+, +:preferred_backup_window+
+    # +:backup_retention_period+, +:preferred_backup_window+, +:multi_az+, +:engine_version+,
+    # +:auto_minor_version_upgrade+, +:allow_major_version_upgrade+
+    #
+    #    rds.modify_db_instance('kd-delete-me-01',
+    #                           :master_user_password => 'newpassword',
+    #                           :instance_class => 'db.m1.large',
+    #                           :multi_az => false,
+    #                           :allocated_storage => 30,
+    #                           :allow_major_version_upgrade => true,
+    #                           :auto_minor_version_upgrade => true,
+    #                           :preferred_maintenance_window => 'sun:06:00-sun:10:00',
+    #                           :preferred_backup_window => '02:00-04:00',
+    #                           :apply_immediately => true,
+    #                           :backup_retention_period => 2) #=>
+    #        {:engine_version=>"5.1.50",
+    #         :aws_id=>"kd-delete-me-01",
+    #         :multi_az=>true,
+    #         :status=>"available",
+    #         :read_replica_db_instance_identifiers=>[],
+    #         :availability_zone=>"us-east-1d",
+    #         :auto_minor_version_upgrade=>true,
+    #         :master_username=>"username",
+    #         :preferred_maintenance_window=>"sun:06:00-sun:10:00",
+    #         :db_parameter_group=>{:status=>"in-sync", :name=>"default.mysql5.1"},
+    #         :create_time=>"2010-11-17T10:21:59.720Z",
+    #         :preferred_backup_window=>"02:00-04:00",
+    #         :engine=>"mysql",
+    #         :db_security_groups=>[{:status=>"active", :name=>"default"}],
+    #         :endpoint_address=>"kd-delete-me-01.chxspydgchoo.us-east-1.rds.amazonaws.com",
+    #         :instance_class=>"db.m1.small",
+    #         :latest_restorable_time=>"2010-11-17T10:27:17.089Z",
+    #         :backup_retention_period=>2,
+    #         :pending_modified_values=>
+    #          {:multi_az=>false, :master_user_password=>"****", :allocated_storage=>30, :instance_class=>"db.m1.large"},
+    #         :allocated_storage=>25}
     #
     def modify_db_instance(aws_id, params={})
       request_hash = {}
       # Mandatory
       request_hash['DBInstanceIdentifier'] = aws_id
       # Optional
-      request_hash['MasterUserPassword']         = params[:master_user_password]           unless params[:master_user_password].blank?
-      request_hash['DBInstanceClass']            = params[:instance_class].to_s.capitalize unless params[:instance_class].blank?
-      request_hash['PreferredMaintenanceWindow'] = params[:preferred_maintenance_window]   unless params[:preferred_maintenance_window].blank?
-      request_hash['BackupRetentionPeriod']      = params[:backup_retention_period]        unless params[:backup_retention_period].blank?
-      request_hash['PreferredBackupWindow']      = params[:preferred_backup_window]        unless params[:preferred_backup_window].blank?
-      request_hash['AllocatedStorage']           = params[:allocated_storage]              unless params[:allocated_storage].blank?
-      request_hash['ApplyImmediately']           = params[:apply_immediately].to_s         unless params[:apply_immediately].blank?
+      request_hash['MasterUserPassword']         = params[:master_user_password]            unless params[:master_user_password].right_blank?
+      request_hash['DBInstanceClass']            = params[:instance_class].to_s.capitalize  unless params[:instance_class].right_blank?
+      request_hash['PreferredMaintenanceWindow'] = params[:preferred_maintenance_window]    unless params[:preferred_maintenance_window].right_blank?
+      request_hash['BackupRetentionPeriod']      = params[:backup_retention_period]         unless params[:backup_retention_period].right_blank?
+      request_hash['PreferredBackupWindow']      = params[:preferred_backup_window]         unless params[:preferred_backup_window].right_blank?
+      request_hash['AllocatedStorage']           = params[:allocated_storage]               unless params[:allocated_storage].right_blank?
+      request_hash['MultiAZ']                    = params[:multi_az].to_s                   unless params[:multi_az].nil?
+      request_hash['EngineVersion']              = params[:engine_version]                  unless params[:engine_version].right_blank?
+      request_hash['AutoMinorVersionUpgrade']    = params[:auto_minor_version_upgrade].to_s unless params[:auto_minor_version_upgrade].nil?
+      request_hash['AllowMajorVersionUpgrade']   = params[:allow_major_version_upgrade].to_s unless params[:allow_major_version_upgrade].nil?
+      request_hash['ApplyImmediately']           = params[:apply_immediately].to_s          unless params[:apply_immediately].right_blank?
       request_hash.merge!(amazonize_list('DBSecurityGroups.member',  params[:db_security_groups]))
-#      request_hash.merge!(amazonize_list('DBParameterGroups.member', params[:db_parameter_groups]))
-      request_hash['DBParameterGroupName']       = params[:db_parameter_group]             unless params[:db_parameter_group].blank?
+      request_hash['DBParameterGroupName']       = params[:db_parameter_group]              unless params[:db_parameter_group].right_blank?
       link = generate_request('ModifyDBInstance', request_hash)
       request_info(link, DescribeDbInstancesParser.new(:logger => @logger))[:db_instances].first
     end
@@ -271,11 +324,11 @@ module RightAws
       request_hash = {}
       request_hash['DBInstanceIdentifier'] = aws_id
       request_hash['SkipFinalSnapshot']    = params.has_key?(:skip_final_snapshot) ? params[:skip_final_snapshot].to_s : 'false'
-      if request_hash['SkipFinalSnapshot'] == 'false' && params[:snapshot_aws_id].blank?
+      if request_hash['SkipFinalSnapshot'] == 'false' && params[:snapshot_aws_id].right_blank?
         params = params.dup
         params[:snapshot_aws_id] = "#{aws_id}-final-snapshot-#{Time.now.utc.strftime('%Y%m%d%H%M%S')}"
       end
-      request_hash['FinalDBSnapshotIdentifier'] = params[:snapshot_aws_id] unless params[:snapshot_aws_id].blank?
+      request_hash['FinalDBSnapshotIdentifier'] = params[:snapshot_aws_id] unless params[:snapshot_aws_id].right_blank?
       link = generate_request('DeleteDBInstance', request_hash)
       request_info(link, DescribeDbInstancesParser.new(:logger => @logger))[:db_instances].first
     end
@@ -316,8 +369,8 @@ module RightAws
     #  rds.describe_db_security_groups('kd3')
     #
     def describe_db_security_groups(*db_security_group_name, &block)
-      item, params = AwsUtils::split_items_and_params(db_security_group_name)
-      params['DBSecurityGroupName'] = item if item
+      items, params = AwsUtils::split_items_and_params(db_security_group_name)
+      params['DBSecurityGroupName'] = items.first unless items.right_blank?
       result = []
       incrementally_list_items('DescribeDBSecurityGroups', DescribeDbSecurityGroupsParser, params) do |response|
         result += response[:db_security_groups]
@@ -344,9 +397,9 @@ module RightAws
 
     def modify_db_security_group_ingress(action, db_security_group_name, params={}) # :nodoc:
       request_hash = { 'DBSecurityGroupName' => db_security_group_name}
-      request_hash['CIDRIP']                  = params[:cidrip]                   unless params[:cidrip].blank?
-      request_hash['EC2SecurityGroupName']    = params[:ec2_security_group_name]  unless params[:ec2_security_group_name].blank?
-      request_hash['EC2SecurityGroupOwnerId'] = params[:ec2_security_group_owner] unless params[:ec2_security_group_owner].blank?
+      request_hash['CIDRIP']                  = params[:cidrip]                   unless params[:cidrip].right_blank?
+      request_hash['EC2SecurityGroupName']    = params[:ec2_security_group_name]  unless params[:ec2_security_group_name].right_blank?
+      request_hash['EC2SecurityGroupOwnerId'] = params[:ec2_security_group_owner] unless params[:ec2_security_group_owner].right_blank?
       link = generate_request(action, request_hash)
       request_info(link, DescribeDbSecurityGroupsParser.new(:logger => @logger))[:db_security_groups].first
     end
@@ -433,8 +486,8 @@ module RightAws
     #  end
     #
     def describe_db_parameter_groups(*db_parameter_group_name, &block)
-      item, params = AwsUtils::split_items_and_params(db_parameter_group_name)
-      params['DBParameterGroupName'] = item if item
+      items, params = AwsUtils::split_items_and_params(db_parameter_group_name)
+      params['DBParameterGroupName'] = items.first unless items.right_blank?
       result = []
       incrementally_list_items('DescribeDBParameterGroups', DescribeDbParameterGroupsParser, params) do |response|
         result += response[:db_parameter_groups]
@@ -449,15 +502,14 @@ module RightAws
     #
     #  TODO: this call returns an empty hash, but should be a parameter group data - ask Amazon guys.
     #
-    def create_db_parameter_group(db_parameter_group_name, db_parameter_group_description, engine='MySQL5.1', params={})
-      params['DBParameterGroupName'] = db_parameter_group_name
-      params['Description']          = db_parameter_group_description
-      params['Engine']               = engine
+    def create_db_parameter_group(db_parameter_group_name, db_parameter_group_description, db_parameter_group_family='mysql5.1', params={})
+      params['DBParameterGroupName']   = db_parameter_group_name
+      params['Description']            = db_parameter_group_description
+      params['DBParameterGroupFamily'] = db_parameter_group_family
       link = generate_request('CreateDBParameterGroup', params )
       request_info(link, DescribeDbParameterGroupsParser.new(:logger => @logger))[:db_parameter_groups].first
     end
 
-
     # Modify DBParameterGroup paramaters. Up to 20 params can be midified at once.
     #
     #  rds.modify_db_parameter_group('kd1', 'max_allowed_packet' => 2048) #=> true
@@ -470,7 +522,7 @@ module RightAws
       params.each do |key, value|
         method = 'pending-reboot'
         if value.is_a?(Hash)
-          method = value[:method] unless value[:method].blank?
+          method = value[:method] unless value[:method].right_blank?
           value  = value[:value]
         end
         parameters << [key, value, method]
@@ -557,7 +609,7 @@ module RightAws
       result
     end
 
-    # Describe a default parameters for the engine.
+    # Describe a default parameters for the parameter group family.
     #
     #  rds.describe_engine_default_parameters('MySQL5.1') #=>
     #    [{:is_modifiable=>true,
@@ -575,10 +627,10 @@ module RightAws
     #      :name=>"auto_increment_increment",
     #      :data_type=>"integer"}, ... ]
     #
-    def describe_engine_default_parameters(*engine, &block)
-      engine = ['MySQL5.1'] if engine.blank?
-      item, params = AwsUtils::split_items_and_params(engine)
-      params['Engine'] = item if item
+    def describe_engine_default_parameters(*db_parameter_group_family, &block)
+      db_parameter_group_family = ['MySQL5.1'] if db_parameter_group_family.right_blank?
+      item, params = AwsUtils::split_items_and_params(db_parameter_group_family)
+      params['DBParameterGroupFamily'] = item if item
       result = []
       incrementally_list_items('DescribeEngineDefaultParameters', DescribeDbParametersParser, params) do |response|
         result += response[:parameters]
@@ -587,6 +639,31 @@ module RightAws
       result
     end
 
+    # Describe a list of orderable DB Instance options for the specified engine.
+    # Optionals: +:instance_class+, +:engine_version+ , +:license_model+
+    #
+    #  rds.describe_orderable_db_instance_options('oracle-ee', :engine_version => '11.2.0.2.v2') #=>
+    #    [{:read_replica_capable=>false,
+    #      :instance_class=>"db.m1.large",
+    #      :availability_zones=>["us-east-1a", "us-east-1b", "us-east-1d"],
+    #      :engine=>"oracle-ee",
+    #      :license_model=>"bring-your-own-license",
+    #      :engine_version=>"11.2.0.2.v2",
+    #      :multi_az_capable=>"false"}, ... ]
+    #
+    def describe_orderable_db_instance_options(engine, params={}, &block)
+      request_hash = { 'Engine' => engine }
+      request_hash['DBInstanceClass'] = params[:instance_class] unless params[:instance_class].right_blank?
+      request_hash['EngineVersion']   = params[:engine_version]    unless params[:engine_version].right_blank?
+      request_hash['LicenseModel']    = params[:license_model]     unless params[:license_model].right_blank?
+      result = []
+      incrementally_list_items('DescribeOrderableDBInstanceOptions', DescribeOrderableDBInstanceOptionsParser, request_hash) do |response|
+        result += response[:items]
+        block ? block.call(response) : true
+      end
+      result
+    end
+    
     # --------------------------------------------
     #  DB Snapshots
     # --------------------------------------------
@@ -636,7 +713,7 @@ module RightAws
     def describe_db_snapshots(params={}, &block)
       item, params = AwsUtils::split_items_and_params(params)
       params['DBSnapshotIdentifier'] = item if item
-      params['DBInstanceIdentifier'] = params.delete(:instance_aws_id) unless params[:instance_aws_id].blank?
+      params['DBInstanceIdentifier'] = params.delete(:instance_aws_id) unless params[:instance_aws_id].right_blank?
       result = []
       incrementally_list_items('DescribeDBSnapshots', DescribeDbSnapshotsParser, params) do |response|
         result += response[:db_snapshots]
@@ -667,7 +744,8 @@ module RightAws
     # Create a new RDS instance from a DBSnapshot. The source DBSnapshot must be
     # in the "Available" state. The new RDS instance is created with the Default security group.
     #
-    # Optional params: +:instance_class+, +:endpoint_port+, +:availability_zone+
+    # Optional params: +:instance_class+, +:endpoint_port+, +:availability_zone+, +:multi_az+,
+    # +:auto_minor_version_upgrade+, +:license_model+, +:db_name+, +:engine+
     #
     #  rds.restore_db_instance_from_db_snapshot('ahahahaha-final-snapshot-20090828081159', 'q1') #=>
     #    {:status=>"creating",
@@ -680,14 +758,20 @@ module RightAws
     #     :create_time=>"2009-08-29T18:07:01.510Z",
     #     :instance_class=>"Medium",
     #     :preferred_maintenance_window=>"Sun:05:00-Sun:09:00",
-    #     :engine=>"MySQL5.1"}
+    #     :engine=>"MySQL",
+    #     :engine_version=>"5.1.49"}
     #
     def restore_db_instance_from_db_snapshot(snapshot_aws_id, instance_aws_id, params={})
       request_hash = { 'DBSnapshotIdentifier' => snapshot_aws_id,
                        'DBInstanceIdentifier' => instance_aws_id }
-      request_hash['DBInstanceClass']  = params[:instance_class]    unless params[:instance_class].blank?
-      request_hash['EndpointPort']     = params[:endpoint_port]     unless params[:endpoint_port].blank?
-      request_hash['AvailabilityZone'] = params[:availability_zone] unless params[:availability_zone].blank?
+      request_hash['DBInstanceClass']         = params[:instance_class]             unless params[:instance_class].right_blank?
+      request_hash['Port']                    = params[:endpoint_port]              unless params[:endpoint_port].right_blank?
+      request_hash['AvailabilityZone']        = params[:availability_zone]          unless params[:availability_zone].right_blank?
+      request_hash['MultiAZ']                 = params[:multi_az]                   unless params[:multi_az].nil?
+      request_hash['AutoMinorVersionUpgrade'] = params[:auto_minor_version_upgrade] unless params[:auto_minor_version_upgrade].nil?
+      request_hash['LicenseModel']            = params[:license_model]              unless params[:license_model].right_blank?
+      request_hash['DBName']                  = params[:db_name]                    unless params[:db_name].right_blank?
+      request_hash['Engine']                  = params[:engine]                     unless params[:enginel].right_blank?
       link = generate_request('RestoreDBInstanceFromDBSnapshot', request_hash)
       request_info(link, DescribeDbInstancesParser.new(:logger => @logger))[:db_instances].first
     end
@@ -696,10 +780,23 @@ module RightAws
     # database is created from the source database restore point with the same configuration as
     # the original source database, except that the new RDS instance is created with the default
     # security group.
-    def restore_db_instance_to_point_in_time(instance_aws_id, new_instance_aws_id, restore_time)
+    #
+    # Optional params: +:instance_class+, +:endpoint_port+, +:availability_zone+, +:multi_az+, +:restore_time+,
+    # +:auto_minor_version_upgrade+, +:use_latest_restorable_time+, +:license_model+, +:db_name+, +:engine+
+    #
+    def restore_db_instance_to_point_in_time(instance_aws_id, new_instance_aws_id, params={})
       request_hash = { 'SourceDBInstanceIdentifier' => instance_aws_id,
-                       'TargetDBInstanceIdentifier' => new_instance_aws_id,
-                       'RestoreTime' => restore_time}
+                       'TargetDBInstanceIdentifier' => new_instance_aws_id}
+      request_hash['UseLatestRestorableTime'] = params[:use_latest_restorable_time].to_s unless params[:use_latest_restorable_time].nil?
+      request_hash['RestoreTime']             = params[:restore_time]               unless params[:restore_time].right_blank?
+      request_hash['DBInstanceClass']         = params[:instance_class]             unless params[:instance_class].right_blank?
+      request_hash['MultiAZ']                 = params[:multi_az]                   unless params[:multi_az].nil?
+      request_hash['Port']                    = params[:endpoint_port]              unless params[:endpoint_port].right_blank?
+      request_hash['AvailabilityZone']        = params[:availability_zone]          unless params[:availability_zone].right_blank?
+      request_hash['AutoMinorVersionUpgrade'] = params[:auto_minor_version_upgrade] unless params[:auto_minor_version_upgrade].nil?
+      request_hash['LicenseModel']            = params[:license_model]              unless params[:license_model].right_blank?
+      request_hash['DBName']                  = params[:db_name]                    unless params[:db_name].right_blank?
+      request_hash['Engine']                  = params[:engine]                     unless params[:enginel].right_blank?
       link = generate_request('RestoreDBInstanceToPointInTime', request_hash)
       request_info(link, DescribeDbInstancesParser.new(:logger => @logger))[:db_instances].first
     end
@@ -754,11 +851,11 @@ module RightAws
     #
     def describe_events(params={}, &block)
       params = params.dup
-      params['SourceIdentifier'] = params.delete(:aws_id)                unless params[:aws_id].blank?
-      params['SourceType']       = params.delete(:source_type)           unless params[:source_type].blank?
-      params['Duration']         = params.delete(:duration)              unless params[:duration].blank?
-      params['StartDate']        = fix_date(params.delete(:start_date))  unless params[:start_date].blank?
-      params['EndDate']          = fix_date(params.delete(:end_date))    unless params[:end_date].blank?
+      params['SourceIdentifier'] = params.delete(:aws_id)                unless params[:aws_id].right_blank?
+      params['SourceType']       = params.delete(:source_type)           unless params[:source_type].right_blank?
+      params['Duration']         = params.delete(:duration)              unless params[:duration].right_blank?
+      params['StartDate']        = fix_date(params.delete(:start_date))  unless params[:start_date].right_blank?
+      params['EndDate']          = fix_date(params.delete(:end_date))    unless params[:end_date].right_blank?
       result = []
       incrementally_list_items('DescribeEvents', DescribeEventsParser, params) do |response|
         result += response[:events]
@@ -773,6 +870,175 @@ module RightAws
       date
     end
 
+    # --------------------------------------------
+    #  DB Engine Versions
+    # --------------------------------------------
+
+    # Get a list of the available DB engines.
+    # Optional params: +:db_parameter_group_family+, +:default_only+, +:engine+, +:engine_version+
+    #
+    #  rds.describe_db_engine_versions #=>
+    #    [{:db_parameter_group_family=>"mysql5.1",
+    #      :engine=>"mysql",
+    #      :db_engine_description=>"MySQL Community Edition",
+    #      :db_engine_version_description=>"Mysql 5.1.45",
+    #      :engine_version=>"5.1.45"},
+    #     {:db_parameter_group_family=>"oracle-se1-11.2",
+    #      :engine=>"oracle-se1",
+    #      :db_engine_description=>"Oracle Database Standard Edition One",
+    #      :db_engine_version_description=>
+    #       "Oracle Standard Edition One - DB Engine Version 11.2.0.2.v2",
+    #      :engine_version=>"11.2.0.2.v2"}]
+    #
+    def describe_db_engine_versions(params={}, &block)
+      params = params.dup
+      params['DBParameterGroupFamily'] = params.delete(:db_parameter_group_family) unless params[:db_parameter_group_family].right_blank?
+      params['DefaultOnly']            = params.delete(:default_only).to_s         unless params[:default_only].nil?
+      params['Engine']                 = params.delete(:engine)                    unless params[:engine].right_blank?
+      params['EngineVersion']          = params.delete(:engine_version)            unless params[:engine_version].right_blank?
+      result = []
+      incrementally_list_items('DescribeDBEngineVersions', DescribeDBEngineVersionsParser, params) do |response|
+        result += response[:db_engine_versions]
+        block ? block.call(response) : true
+      end
+      result
+    end
+
+    # --------------------------------------------
+    #  DB Replicas
+    # --------------------------------------------
+
+    # Create a DB Instance that acts as a Read Replica of a source DB Instance.
+    #
+    # Optional params: +:endpoint_port+, +:availability_zone+, +:instance_class+, +:auto_minor_version_upgrade+
+    #
+    #    rds.create_db_instance_read_replica('kd-delete-me-01-replica-01', 'kd-delete-me-01',
+    #                                        :instance_class => 'db.m1.small',
+    #                                        :endpoint_port => '11000',
+    #                                        :auto_minor_version_upgrade => false ) #=>
+    #      {:auto_minor_version_upgrade=>false,
+    #       :read_replica_source_db_instance_identifier=>"kd-delete-me-01",
+    #       :status=>"creating",
+    #       :backup_retention_period=>0,
+    #       :allocated_storage=>30,
+    #       :read_replica_db_instance_identifiers=>[],
+    #       :engine_version=>"5.1.50",
+    #       :aws_id=>"kd-delete-me-01-replica-01",
+    #       :multi_az=>false,
+    #       :preferred_maintenance_window=>"sun:06:00-sun:10:00",
+    #       :master_username=>"username",
+    #       :preferred_backup_window=>"02:00-04:00",
+    #       :db_parameter_group=>{:status=>"in-sync", :name=>"default.mysql5.1"},
+    #       :engine=>"mysql",
+    #       :db_security_groups=>[{:status=>"active", :name=>"default"}],
+    #       :instance_class=>"db.m1.small",
+    #       :pending_modified_values=>{}}
+    #
+    def create_db_instance_read_replica(aws_id, source_db_instance_identifier, params={})
+      request_hash = { 'DBInstanceIdentifier'       => aws_id,
+                       'SourceDBInstanceIdentifier' => source_db_instance_identifier}
+      request_hash['Port']                    = params[:endpoint_port]                   unless params[:endpoint_port].right_blank?
+      request_hash['AvailabilityZone']        = params[:availability_zone]               unless params[:availability_zone].right_blank?
+      request_hash['DBInstanceClass']         = params[:instance_class]                  unless params[:instance_class].right_blank?
+      request_hash['AutoMinorVersionUpgrade'] = params[:auto_minor_version_upgrade].to_s unless params[:auto_minor_version_upgrade].nil?
+      link = generate_request('CreateDBInstanceReadReplica', request_hash)
+      request_info(link, DescribeDbInstancesParser.new(:logger => @logger))[:db_instances].first
+    end
+
+
+    #---------------------------------------------
+    #  Reserved Instances
+    #---------------------------------------------
+
+    # Lists available reserved DB Instance offerings.
+    # Options: :aws_id, :instance_class, :duration, :product_description, :multi_az
+    #
+    #  rds.describe_reserved_db_instances_offerings #=>
+    #    [{:usage_price=>0.262,
+    #      :offering_aws_id=>"248e7b75-2451-4381-9025-b5553d421c7b",
+    #      :multi_az=>false,
+    #      :duration=>31536000,
+    #      :currency_code=>"USD",
+    #      :instance_class=>"db.m2.xlarge",
+    #      :product_description=>"mysql",
+    #      :fixed_price=>1325.0},
+    #     {:usage_price=>0.092,
+    #      :offering_aws_id=>"248e7b75-49a7-4cd7-9a9b-354f4906a9b1",
+    #      :multi_az=>true,
+    #      :duration=>94608000,
+    #      :currency_code=>"USD",
+    #      :instance_class=>"db.m1.small",
+    #      :product_description=>"mysql",
+    #      :fixed_price=>700.0},   ...]
+    #
+    #  rds.describe_reserved_db_instances_offerings(:aws_id => "248e7b75-49a7-4cd7-9a9b-354f4906a9b1") #=>
+    #    [{:duration=>94608000,
+    #      :multi_az=>true,
+    #      :fixed_price=>700.0,
+    #      :usage_price=>0.092,
+    #      :currency_code=>"USD",
+    #      :aws_id=>"248e7b75-49a7-4cd7-9a9b-354f4906a9b1",
+    #      :instance_class=>"db.m1.small",
+    #      :product_description=>"mysql"}]
+    #
+    #  rds.describe_reserved_db_instances_offerings(:instance_class => "db.m1.small")
+    #  rds.describe_reserved_db_instances_offerings(:duration => 31536000)
+    #  rds.describe_reserved_db_instances_offerings(:product_description => 'mysql')
+    #  rds.describe_reserved_db_instances_offerings(:multi_az => true)
+    #
+    def describe_reserved_db_instances_offerings(params={}, &block)
+      params = params.dup
+      params['ReservedDBInstancesOfferingId'] = params.delete(:aws_id)              unless params[:aws_id].right_blank?
+      params['DBInstanceClass']               = params.delete(:instance_class)      unless params[:instance_class].right_blank?
+      params['Duration']                      = params.delete(:duration)            unless params[:duration].right_blank?
+      params['ProductDescription']            = params.delete(:product_description) unless params[:product_description].right_blank?
+      params['MultiAZ']                       = params.delete(:multi_az).to_s       unless params[:multi_az].nil?
+      result = []
+      incrementally_list_items('DescribeReservedDBInstancesOfferings', DescribeReservedDBInstancesOfferingsParser, params) do |response|
+        result += response[:reserved_db_instances_offerings]
+        block ? block.call(response) : true
+      end
+      result
+    end
+
+    # Returns information about reserved DB Instances for this account, or about
+    # a specified reserved DB Instance.
+    # Options: :aws_id, :offering_aws_id, :instance_class, :duration, :product_description, :multi_az
+    #
+    #  rds.describe_reserved_db_instances
+    #  rds.describe_reserved_db_instances(:aws_id => "myreservedinstance")
+    #  rds.describe_reserved_db_instances(:offering_aws_id => "248e7b75-49a7-4cd7-9a9b-354f4906a9b1")
+    #  rds.describe_reserved_db_instances(:instance_class => "db.m1.small")
+    #  rds.describe_reserved_db_instances(:duration => 31536000)
+    #  rds.describe_reserved_db_instances(:product_description => 'mysql')
+    #  rds.describe_reserved_db_instances_offerings(:multi_az => true)
+    #
+    def describe_reserved_db_instances(params={}, &block)
+      params = params.dup
+      params['ReservedDBInstancesId']         = params.delete(:aws_id)              unless params[:aws_id].right_blank?
+      params['ReservedDBInstancesOfferingId'] = params.delete(:offering_aws_id)     unless params[:offering_aws_id].right_blank?
+      params['DBInstanceClass']               = params.delete(:instance_class)      unless params[:instance_class].right_blank?
+      params['Duration']                      = params.delete(:duration)            unless params[:duration].right_blank?
+      params['ProductDescription']            = params.delete(:product_description) unless params[:product_description].right_blank?
+      params['MultiAZ']                       = params.delete(:multi_az).to_s       unless params[:multi_az].nil?
+      result = []
+      incrementally_list_items('DescribeReservedDBInstances', DescribeReservedDBInstancesParser, params) do |response|
+        result += response[:reserved_db_instances]
+        block ? block.call(response) : true
+      end
+      result
+    end
+
+    # Purchases a reserved DB Instance offering.
+    # Options: :aws_id, :count
+    def purchase_reserved_db_instances_offering(offering_aws_id, params={})
+      request_hash = { 'ReservedDBInstancesOfferingId' => offering_aws_id }
+      request_hash['ReservedDBInstanceId'] = params[:aws_id] unless params[:aws_id].right_blank?
+      request_hash['DBInstanceCount']      = params[:count]  unless params[:count].right_blank?
+      link = generate_request('PurchaseReservedDBInstancesOffering', request_hash)
+      request_info(link, DescribeReservedDBInstancesParser.new(:logger => @logger))[:reserved_db_instances].first
+    end
+    
     # --------------------------------------------
     #  Parsers
     # --------------------------------------------
@@ -783,54 +1049,88 @@ module RightAws
 
     class DescribeDbInstancesParser < RightAWSParser # :nodoc:
       def reset
-        @m = [ 'DBInstance',
-               'CreateDBInstanceResult',
-               'DeleteDBInstanceResult',
-               'ModifyDBInstanceResult',
-               'RebootDBInstanceResult',
-               'RestoreDBInstanceToPointInTimeResponse',
-               'RestoreDBInstanceFromDBSnapshotResult' ]
         @result = { :db_instances => [] }
       end
       def tagstart(name, attributes)
         case name
-          when *@m               then @db_instance = { :db_security_groups => [], 
-                                                       :pending_modified_values => {} }
-          when 'DBSecurityGroup' then @db_security_group = {}
-          when 'DBParameterGroup', 'DBParameterGroupStatus' then @db_parameter_group = {}
+        when 'DBInstance'             then @item = { :db_security_groups => [], :pending_modified_values => {}, :read_replica_db_instance_identifiers => [] }
+        when 'DBSecurityGroup'        then @db_security_group = {}
+        when 'DBParameterGroup',
+             'DBParameterGroupStatus' then @db_parameter_group = {}
         end
       end
       def tagend(name)
         case name
-        when 'Marker'                     then @result[:marker]       = @text
-        when 'MaxRecords'                 then @result[:max_records]  = @text.to_i
-        when 'DBInstanceIdentifier'       then @db_instance[:aws_id]               = @text
-        when 'DBName'                     then @db_instance[:name]                 = @text  # ? is this one used?
-        when 'InstanceCreateTime'         then @db_instance[:create_time]          = @text
-        when 'Engine'                     then @db_instance[:engine]               = @text
-        when 'DBInstanceStatus'           then @db_instance[:status]               = @text
-        when 'AllocatedStorage'           then @db_instance[:allocated_storage]    = @text.to_i
-        when 'Port'                       then @db_instance[:endpoint_port]        = @text.to_i
-        when 'Address'                    then @db_instance[:endpoint_address]     = @text
-        when 'MasterUsername'             then @db_instance[:master_username]      = @text
-        when 'AvailabilityZone'           then @db_instance[:availability_zone]    = @text
-        when 'PreferredMaintenanceWindow' then @db_instance[:preferred_maintenance_window] = @text
-        when 'BackupRetentionPeriod'      then @db_instance[:backup_retention_period] = @text
-        when 'PreferredBackupWindow'      then @db_instance[:preferred_backup_window] = @text
-        when 'DBInstanceClass'
-          case @xmlpath
-          when /PendingModifiedValues$/ then @db_instance[:pending_modified_values][:instance_class] = @text
-          else                               @db_instance[:instance_class] = @text
+        when 'Marker'                                then @result[:marker]               = @text
+        when 'MaxRecords'                            then @result[:max_records]          = @text.to_i
+        when 'DBInstanceIdentifier'                  then @item[:aws_id]                 = @text
+        when 'InstanceCreateTime'                    then @item[:create_time]            = @text
+        when 'Engine'                                then @item[:engine]                 = @text
+        when 'DBInstanceStatus'                      then @item[:status]                 = @text
+        when 'Address'                               then @item[:endpoint_address]       = @text
+        when 'Port'                                  then @item[:endpoint_port]          = @text.to_i
+        when 'MasterUsername'                        then @item[:master_username]        = @text
+        when 'AvailabilityZone'                      then @item[:availability_zone]      = @text
+        when 'LatestRestorableTime'                  then @item[:latest_restorable_time] = @text
+        when 'LicenseModel'                          then @item[:license_model]          = @text
+        when 'DBName'                                then @item[:db_name]                = @text
+        when 'ReadReplicaSourceDBInstanceIdentifier' then @item[:read_replica_source_db_instance_identifier] = @text
+        when 'ReadReplicaDBInstanceIdentifier'       then @item[:read_replica_db_instance_identifiers]      << @text
+        when 'DBSecurityGroupName'                   then @db_security_group[:name]             = @text
+        when 'Status'                                then @db_security_group[:status]           = @text
+        when 'DBParameterGroupName'                  then @db_parameter_group[:name]            = @text
+        when 'ParameterApplyStatus'                  then @db_parameter_group[:status]          = @text
+        when 'DBSecurityGroup'                       then @item[:db_security_groups] << @db_security_group
+        when 'DBParameterGroup',
+             'DBParameterGroupStatus'                then @item[:db_parameter_group] = @db_parameter_group
+        when 'DBInstance'                            then @result[:db_instances]            << @item
+        else
+          case full_tag_name
+          when %r{DBInstance/DBInstanceClass$}                       then @item[:instance_class]               = @text
+          when %r{DBInstance/AllocatedStorage$}                      then @item[:allocated_storage]            = @text.to_i
+          when %r{DBInstance/MultiAZ$}                               then @item[:multi_az]                     = (@text == 'true')
+          when %r{DBInstance/BackupRetentionPeriod$}                 then @item[:backup_retention_period]      = @text.to_i
+          when %r{DBInstance/PreferredMaintenanceWindow$}            then @item[:preferred_maintenance_window] = @text
+          when %r{DBInstance/PreferredBackupWindow$}                 then @item[:preferred_backup_window]      = @text
+          when %r{DBInstance/EngineVersion$}                         then @item[:engine_version]               = @text
+          when %r{DBInstance/AutoMinorVersionUpgrade$}               then @item[:auto_minor_version_upgrade]   = (@text == 'true')
+          when %r{DBInstance/AllowMajorVersionUpgrade$}              then @item[:allow_major_version_upgrade]  = (@text == 'true')
+          when %r{PendingModifiedValues/DBInstanceClass$}            then @item[:pending_modified_values][:instance_class]               = @text
+          when %r{PendingModifiedValues/AllocatedStorage$}           then @item[:pending_modified_values][:allocated_storage]            = @text.to_i
+          when %r{PendingModifiedValues/MasterUserPassword$}         then @item[:pending_modified_values][:master_user_password]         = @text
+          when %r{PendingModifiedValues/MultiAZ$}                    then @item[:pending_modified_values][:multi_az]                     = (@text == 'true')
+          when %r{PendingModifiedValues/BackupRetentionPeriod$}      then @item[:pending_modified_values][:backup_retention_period]      = @text.to_i
+          when %r{PendingModifiedValues/PreferredMaintenanceWindow$} then @item[:pending_modified_values][:preferred_maintenance_window] = @text
+          when %r{PendingModifiedValues/PreferredBackupWindow$}      then @item[:pending_modified_values][:preferred_backup_window]      = @text
+          when %r{PendingModifiedValues/EngineVersion$}              then @item[:pending_modified_values][:engine_version]               = @text
+          when %r{PendingModifiedValues/AutoMinorVersionUpgrade$}    then @item[:pending_modified_values][:auto_minor_version_upgrade]   = (@text == 'true')
+          when %r{PendingModifiedValues/AllowMajorVersionUpgrade$}   then @item[:pending_modified_values][:allow_major_version_upgrade]  = (@text == 'true')
           end
-        when 'MasterUserPassword'         then @db_instance[:pending_modified_values][:master_user_password] = @text
-        when 'DBSecurityGroupName'        then @db_security_group[:name]   = @text
-        when 'Status'                     then @db_security_group[:status] = @text
-        when 'DBParameterGroupName'       then @db_parameter_group[:name]   = @text
-        when 'ParameterApplyStatus'       then @db_parameter_group[:status] = @text
-        when 'DBSecurityGroup'            then @db_instance[:db_security_groups] << @db_security_group
-        when 'DBParameterGroup','DBParameterGroupStatus'
-          @db_instance[:db_parameter_group] = @db_parameter_group
-        when *@m                          then @result[:db_instances]            << @db_instance
+        end
+      end
+    end
+
+    class DescribeOrderableDBInstanceOptionsParser < RightAWSParser # :nodoc:
+      def reset
+        @result = { :items => [] }
+      end
+      def tagstart(name, attributes)
+        case name
+        when 'OrderableDBInstanceOption' then @item = { :availability_zones => [] }
+        end
+      end
+      def tagend(name)
+        case name
+        when 'Marker'                     then @result[:marker]             = @text
+        when 'MaxRecords'                 then @result[:max_records]        = @text.to_i
+        when 'DBInstanceClass'            then @item[:instance_class]       = @text
+        when 'Engine'                     then @item[:engine]               = @text
+        when 'EngineVersion'              then @item[:engine_version]       = @text
+        when 'LicenseModel'               then @item[:license_model]        = @text
+        when 'MultiAZCapable'             then @item[:multi_az_capable]     = @text
+        when 'ReadReplicaCapable'         then @item[:read_replica_capable] = @text == 'true'
+        when 'Name'                       then @item[:availability_zones]  << @text
+        when 'OrderableDBInstanceOption'  then @result[:items]             << @item
         end
       end
     end
@@ -841,41 +1141,37 @@ module RightAws
 
     class DescribeDbSecurityGroupsParser < RightAWSParser # :nodoc:
       def reset
-        @m = [ 'DBSecurityGroup',
-               'CreateDBSecurityGroupResult',
-               'AuthorizeDBSecurityGroupIngressResult',
-               'RevokeDBSecurityGroupIngressResult' ]
         @result = { :db_security_groups => [] }
       end
       def tagstart(name, attributes)
         case name
-          when *@m                then @item     = { :ec2_security_groups => [], :ip_ranges => [] }
-          when 'IPRange'          then @ip_range = {}
-          when 'EC2SecurityGroup' then @ec2_security_group = {}
+        when 'DBSecurityGroup'  then @item               = { :ec2_security_groups => [], :ip_ranges => [] }
+        when 'IPRange'          then @ip_range           = {}
+        when 'EC2SecurityGroup' then @ec2_security_group = {}
         end
       end
       def tagend(name)
         case name
-        when 'Marker'                     then @result[:marker]       = @text
-        when 'MaxRecords'                 then @result[:max_records]  = @text.to_i
-        when 'DBSecurityGroupDescription' then @item[:description] = @text
-        when 'OwnerId'                    then @item[:owner_id]    = @text
-        when 'DBSecurityGroupName'        then @item[:name]        = @text
-        when 'Status'
-          case @xmlpath
-          when /IPRange$/          then @ip_range[:status] = @text
-          when /EC2SecurityGroup$/ then @ec2_security_group[:status] = @text
-          end
-        when 'EC2SecurityGroupName'    then @ec2_security_group[:name]     = @text
-        when 'EC2SecurityGroupOwnerId' then @ec2_security_group[:owner_id] = @text
-        when 'CIDRIP'                  then @ip_range[:cidrip]             = @text
-        when 'IPRange'                 then @item[:ip_ranges]           << @ip_range
-        when 'EC2SecurityGroup'        then @item[:ec2_security_groups] << @ec2_security_group
-        when *@m
+        when 'Marker'                     then @result[:marker]               = @text
+        when 'MaxRecords'                 then @result[:max_records]          = @text.to_i
+        when 'DBSecurityGroupDescription' then @item[:description ]           = @text
+        when 'OwnerId'                    then @item[:owner_id]               = @text
+        when 'DBSecurityGroupName'        then @item[:name]                   = @text
+        when 'EC2SecurityGroupName'       then @ec2_security_group[:name]     = @text
+        when 'EC2SecurityGroupOwnerId'    then @ec2_security_group[:owner_id] = @text
+        when 'CIDRIP'                     then @ip_range[:cidrip]             = @text
+        when 'IPRange'                    then @item[:ip_ranges]             << @ip_range
+        when 'EC2SecurityGroup'           then @item[:ec2_security_groups]   << @ec2_security_group
+        when 'DBSecurityGroup'
           # Sort the ip_ranges and ec2_security_groups
           @item[:ip_ranges].sort!{ |i1,i2| "#{i1[:cidrip]}" <=> "#{i2[:cidrip]}" }
           @item[:ec2_security_groups].sort!{ |i1,i2| "#{i1[:owner_id]}#{i1[:name]}" <=> "#{i2[:owner_id]}#{i2[:name]}" }
           @result[:db_security_groups] << @item
+        else
+          case full_tag_name
+          when %r{IPRange/Status$}          then @ip_range[:status]           = @text
+          when %r{EC2SecurityGroup/Status$} then @ec2_security_group[:status] = @text
+          end
         end
       end
     end
@@ -886,22 +1182,23 @@ module RightAws
 
     class DescribeDbParameterGroupsParser < RightAWSParser # :nodoc:
       def reset
-        @m = [ 'DBParameterGroup', 'CreateDBParameterGroupResult', 'ModifyDBParameterGroupResult' ]
         @result = { :db_parameter_groups => [] }
       end
       def tagstart(name, attributes)
         case name
-          when *@m then @item = { }
+        when 'DBParameterGroup',
+             'ModifyDBParameterGroupResult' then @item = { }
         end
       end
       def tagend(name)
         case name
-        when 'Marker'               then @result[:marker]       = @text
-        when 'MaxRecords'           then @result[:max_records]  = @text.to_i
-        when 'DBParameterGroupName' then @item[:name]        = @text
-        when 'Description'          then @item[:description] = @text
-        when 'Engine'               then @item[:engine]      = @text
-        when *@m                    then @result[:db_parameter_groups] << @item
+        when 'Marker'                 then @result[:marker]       = @text
+        when 'MaxRecords'             then @result[:max_records]  = @text.to_i
+        when 'DBParameterGroupName'   then @item[:name]           = @text
+        when 'Description'            then @item[:description]    = @text
+        when 'DBParameterGroupFamily' then @item[:db_parameter_group_family] = @text
+        when 'DBParameterGroup',
+             'ModifyDBParameterGroupResult' then @result[:db_parameter_groups] << @item
         end
       end
     end
@@ -912,24 +1209,26 @@ module RightAws
       end
       def tagstart(name, attributes)
         case name
-          when 'Parameter' then @item = {}
+        when 'Parameter' then @item = {}
         end
       end
       def tagend(name)
         case name
         when 'Marker'               then @result[:marker]       = @text
         when 'MaxRecords'           then @result[:max_records]  = @text.to_i
-        when 'DBParameterGroupName' then @result[:group_name]   = @text # DescribeDbParametersResponse
-        when 'Engine'               then @result[:engine]       = @text # DescribeDBEngineDefaultParametersResponse
-        when 'DataType'      then @item[:data_type]     = @text
-        when 'Source'        then @item[:source]        = @text
-        when 'Description'   then @item[:description]   = @text
-        when 'IsModifiable'  then @item[:is_modifiable] = @text[/true/] ? true : false
-        when 'ApplyType'     then @item[:apply_type]     = @text
-        when 'AllowedValues' then @item[:allowed_values] = @text
-        when 'ParameterName' then @item[:name]           = @text
-        when 'ParameterValue' then @item[:value]         = @text
-        when 'Parameter'     then @result[:parameters] << @item
+        when 'DBParameterGroupName'   then @result[:group_name]                = @text # DescribeDbParametersResponse
+        when 'DBParameterGroupFamily' then @result[:db_parameter_group_family] = @text # DescribeDBEngineDefaultParametersResponse
+        when 'DataType'             then @item[:data_type]      = @text
+        when 'Source'               then @item[:source]         = @text
+        when 'Description'          then @item[:description]    = @text
+        when 'IsModifiable'         then @item[:is_modifiable]  = (@text == 'true')
+        when 'ApplyType'            then @item[:apply_type]     = @text
+        when 'ApplyMethod'          then @item[:apply_method]   = @text
+        when 'MinimumEngineVersion' then @item[:minimum_engine_version] = @text
+        when 'AllowedValues'        then @item[:allowed_values] = @text
+        when 'ParameterName'        then @item[:name]           = @text
+        when 'ParameterValue'       then @item[:value]          = @text
+        when 'Parameter'            then @result[:parameters]  << @item
         end
       end
     end
@@ -940,30 +1239,30 @@ module RightAws
 
     class DescribeDbSnapshotsParser < RightAWSParser # :nodoc:
       def reset
-        @m = ['DBSnapshot', 'CreateDBSnapshotResult', 'DeleteDBSnapshotResult']
         @result = { :db_snapshots => [] }
       end
       def tagstart(name, attributes)
         case name
-          when *@m
-            @db_snapshot = {}
+        when 'DBSnapshot' then @item = {}
         end
       end
       def tagend(name)
         case name
-        when 'Marker'               then @result[:marker]            = @text
-        when 'MaxRecords'           then @result[:max_records]       = @text.to_i  # ?
-        when 'Engine'               then @db_snapshot[:engine]               = @text
-        when 'InstanceCreateTime'   then @db_snapshot[:instance_create_time] = @text
-        when 'EndpointPort'         then @db_snapshot[:endpoint_port]        = @text.to_i
-        when 'Status'               then @db_snapshot[:status]               = @text
-        when 'AvailabilityZone'     then @db_snapshot[:availability_zone]    = @text
-        when 'MasterUsername'       then @db_snapshot[:master_username]      = @text
-        when 'AllocatedStorage'     then @db_snapshot[:allocated_storage]    = @text.to_i
-        when 'SnapshotCreateTime'   then @db_snapshot[:create_time]          = @text
-        when 'DBInstanceIdentifier' then @db_snapshot[:instance_aws_id]      = @text
-        when 'DBSnapshotIdentifier' then @db_snapshot[:aws_id]               = @text
-        when *@m                    then @result[:db_snapshots]               << @db_snapshot
+        when 'Marker'               then @result[:marker]             = @text
+        when 'MaxRecords'           then @result[:max_records]        = @text.to_i  # ?
+        when 'Engine'               then @item[:engine]               = @text
+        when 'EngineVersion'        then @item[:engine_version]       = @text
+        when 'InstanceCreateTime'   then @item[:instance_create_time] = @text
+        when 'Port'                 then @item[:endpoint_port]        = @text.to_i
+        when 'Status'               then @item[:status]               = @text
+        when 'AvailabilityZone'     then @item[:availability_zone]    = @text
+        when 'MasterUsername'       then @item[:master_username]      = @text
+        when 'AllocatedStorage'     then @item[:allocated_storage]    = @text.to_i
+        when 'SnapshotCreateTime'   then @item[:create_time]          = @text
+        when 'DBInstanceIdentifier' then @item[:instance_aws_id]      = @text
+        when 'DBSnapshotIdentifier' then @item[:aws_id]               = @text
+        when 'LicenseModel'         then @item[:license_model]        = @text
+        when 'DBSnapshot'           then @result[:db_snapshots]      << @item
         end
       end
     end
@@ -978,18 +1277,105 @@ module RightAws
       end
       def tagstart(name, attributes)
         case name
-          when 'Event' then @event = {}
+        when 'Event' then @item = {}
         end
       end
       def tagend(name)
         case name
         when 'Marker'           then @result[:marker]       = @text
         when 'MaxRecords'       then @result[:max_records]  = @text.to_i  # ?
-        when 'Date'             then @event[:date]          = @text
-        when 'SourceIdentifier' then @event[:aws_id]        = @text
-        when 'SourceType'       then @event[:source_type]   = @text
-        when 'Message'          then @event[:message]       = @text
-        when 'Event'            then @result[:events]      << @event
+        when 'Date'             then @item[:date]           = @text
+        when 'SourceIdentifier' then @item[:aws_id]         = @text
+        when 'SourceType'       then @item[:source_type]    = @text
+        when 'Message'          then @item[:message]        = @text
+        when 'Event'            then @result[:events]      << @item
+        end
+      end
+    end
+
+    # --------------------------------------------
+    #  DB Events
+    # --------------------------------------------
+
+    class DescribeDBEngineVersionsParser < RightAWSParser # :nodoc:
+      def reset
+        @result = { :db_engine_versions => [] }
+      end
+      def tagstart(name, attributes)
+        case name
+        when 'DBEngineVersion' then @item = {}
+        end
+      end
+      def tagend(name)
+        case name
+        when 'Marker'                 then @result[:marker]                  = @text
+        when 'MaxRecords'             then @result[:max_records]             = @text.to_i
+        when 'DBParameterGroupFamily' then @item[:db_parameter_group_family] = @text
+        when 'Engine'                 then @item[:engine]                    = @text
+        when 'EngineVersion'          then @item[:engine_version]            = @text
+        when 'DBEngineDescription'    then @item[:db_engine_description]     = @text
+        when 'DBEngineVersionDescription' then @item[:db_engine_version_description] = @text
+        when 'DBEngineVersion'        then @result[:db_engine_versions]     << @item
+        end
+      end
+    end
+
+    # --------------------------------------------
+    #  DB Reserved Instances
+    # --------------------------------------------
+
+    class DescribeReservedDBInstancesOfferingsParser < RightAWSParser # :nodoc:
+      def reset
+        @result = { :reserved_db_instances_offerings => [] }
+      end
+      def tagstart(name, attributes)
+        case name
+        when 'ReservedDBInstancesOffering' then @item = {}
+        end
+      end
+      def tagend(name)
+        case name
+        when 'Marker'                        then @result[:marker]            = @text
+        when 'MaxRecords'                    then @result[:max_records]       = @text.to_i
+        when 'CurrencyCode'                  then @item[:currency_code]       = @text
+        when 'DBInstanceClass'               then @item[:instance_class]      = @text
+        when 'Duration'                      then @item[:duration]            = @text.to_i
+        when 'FixedPrice'                    then @item[:fixed_price]         = @text.to_f
+        when 'UsagePrice'                    then @item[:usage_price]         = @text.to_f
+        when 'MultiAZ'                       then @item[:multi_az]            = (@text == 'true')
+        when 'ProductDescription'            then @item[:product_description] = @text
+        when 'ReservedDBInstancesOfferingId' then @item[:aws_id]              = @text
+        when 'ReservedDBInstancesOffering'   then @result[:reserved_db_instances_offerings] << @item
+        end
+      end
+    end
+
+    class DescribeReservedDBInstancesParser < RightAWSParser # :nodoc:
+      def reset
+        @result = { :reserved_db_instances => [] }
+      end
+      def tagstart(name, attributes)
+        case name
+        when 'ReservedDBInstance' then @item = {}
+        end
+      end
+      def tagend(name)
+        case name
+        when 'Marker'                        then @result[:marker]            = @text
+        when 'MaxRecords'                    then @result[:max_records]       = @text.to_i
+        when 'DBInstanceClass'               then @item[:instance_class]      = @text
+        when 'CurrencyCode'                  then @item[:currency_code]       = @text
+        when 'Duration'                      then @item[:duration]            = @text.to_i
+        when 'FixedPrice'                    then @item[:fixed_price]         = @text.to_f
+        when 'UsagePrice'                    then @item[:usage_price]         = @text.to_f
+        when 'MultiAZ'                       then @item[:multi_az]            = (@text == 'true')
+        when 'ProductDescription'            then @item[:product_description] = @text
+        when 'ReservedDBInstancesOfferingId' then @item[:offering_aws_id]     = @text
+        when 'ReservedDBInstanceId'          then @item[:aws_id]              = @text
+        when 'State'                         then @item[:state]               = @text
+        when 'DBInstanceCount'               then @item[:instance_count]      = @text.to_i
+        when 'StartTime'                     then @item[:start_time]          = @text
+        when 'ReservedDBInstance'            then @result[:reserved_db_instances] << @item
         end
       end
     end