Class: AWS::RDS::Base

Inherits:
Base
  • Object
show all
Defined in:
lib/AWS/RDS.rb,
lib/AWS/RDS/rds.rb

Instance Attribute Summary

Attributes inherited from Base

#port, #proxy_server, #server, #use_ssl

Instance Method Summary (collapse)

Methods inherited from Base

#extract_user_data, #initialize

Constructor Details

This class inherits a constructor from AWS::Base

Instance Method Details

- (Object) api_version



20
21
22
# File 'lib/AWS/RDS.rb', line 20

def api_version
  API_VERSION
end

- (Object) authorize_db_security_group(options = {})

This API method authorizes network ingress for an amazon ec2 group

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_security_group_name (String)

    is the name of the db security group

  • :cidrip (String)

    is the network ip to authorize

  • :ec2_security_group_name (String)

    is the name of the ec2 security group to authorize

  • :ec2_security_group_owner_id (String)

    is the owner id of the security group

Raises:



131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
# File 'lib/AWS/RDS/rds.rb', line 131

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

- (Boolean) aws_error?(response)

Raises the appropriate error if the specified Net::HTTPResponse object contains an Amazon EC2 error; returns false otherwise.

Returns:

  • (Boolean)


30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
# File 'lib/AWS/RDS.rb', line 30

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

- (Object) create_db_instance(options = {})

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

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_instance_identifier (String) — default: nil

    the name of the db_instance

  • :allocated_storage (String)

    in gigabytes (nil)

  • :db_instance_class (String)

    in contains compute and memory capacity (nil)

  • :engine (String)

    type i.e. MySQL5.1 (nil)

  • :master_username (String)

    is the master username for the db instance (nil)

  • :master_user_password (String)

    is the master password for the db instance (nil)

  • :port (String)

    is the port the database accepts connections on (3306)

  • :db_name (String)

    contains the name of the database to create when created (nil)

  • :db_parameter_group (String)

    is the database parameter group to associate with this instance (nil)

  • :db_security_groups (Array)

    are the list of db security groups to associate with the instance (nil)

  • :availability_zone (String)

    is the availability_zone to create the instance in (nil)

  • :preferred_maintenance_window (String)

    in format: ddd:hh24:mi-ddd:hh24:mi (nil)

  • :backup_retention_period (String)

    is the number of days which automated backups are retained (1)

  • :preferred_backup_window (String)

    is the daily time range for which automated backups are created

Raises:



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
# File 'lib/AWS/RDS/rds.rb', line 23

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)

  # handle a former argument that was misspelled
  raise ArgumentError, "Perhaps you meant :backup_retention_period" if options.has?(:backend_retention_period)

  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.merge!(pathlist("DBSecurityGroups.member", [options[:db_security_groups]].flatten)) if options.has_key?(:db_security_groups)
  params["AvailabilityZone"] = options[:availability_zone] if options.has?(:availability_zone)
  params["PreferredMaintenanceWindow"] = options[:preferred_maintenance_window] if options.has?(:preferred_maintenance_window)
  params["BackupRetentionPeriod"] = options[:backup_retention_period].to_s if options.has?(:backup_retention_period)
  params["PreferredBackupWindow"] = options[:preferred_backup_window] if options.has?(:preferred_backup_window)

  return response_generator(:action => "CreateDBInstance", :params => params)
end

- (Object) create_db_parameter_group(options = {})

This API method creates a db parameter group

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_parameter_group_name (String)

    is the name of the parameter group (nil)

  • :engine (String)

    is the engine the db parameter group can be used with (nil)

  • :description (String)

    is the description of the paramter group

Raises:



79
80
81
82
83
84
85
86
87
88
89
90
# File 'lib/AWS/RDS/rds.rb', line 79

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

- (Object) create_db_security_group(options = {})

This API method creates a db security group

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_security_group_name (String)

    is the name of the db security group (nil)

  • :db_security_group_description (String)

    is the description of the db security group

Raises:



97
98
99
100
101
102
103
104
105
106
# File 'lib/AWS/RDS/rds.rb', line 97

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

- (Object) create_db_snapshot(options = {})

This API method creates a restoreable db snapshot

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_snapshot_identifier (String)

    is the identifier of the db snapshot

  • :db_instance_identifier (String)

    is the identifier of the db instance

Raises:



113
114
115
116
117
118
119
120
121
122
# File 'lib/AWS/RDS/rds.rb', line 113

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

- (Object) default_host



24
25
26
# File 'lib/AWS/RDS.rb', line 24

def default_host
  DEFAULT_HOST
end

- (Object) delete_db_instance(options = {})

This API method deletes a db instance identifier

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_instance_identifier (String)

    is the instance identifier for the DB instance to be deleted (nil)

  • :skip_final_snapshot (String)

    determines to create a snapshot or not before it's deleted (no)

  • :final_db_snapshot_identifier (String)

    is the name of the snapshot created before the instance is deleted (name)

Raises:



61
62
63
64
65
66
67
68
69
70
71
# File 'lib/AWS/RDS/rds.rb', line 61

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["FinalDBSnapshotIdentifier"] = options[:final_db_snapshot_identifier].to_s if options.has?(:final_db_snapshot_identifier)

  return response_generator(:action => "DeleteDBInstance", :params => params)
end

- (Object) delete_db_parameter_group(options = {})

This API method deletes a db paramter group

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_parameter_group_name (String)

    is the name of the db paramter group to be deleted (nil)

Raises:



153
154
155
156
157
158
159
160
# File 'lib/AWS/RDS/rds.rb', line 153

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

- (Object) delete_db_security_group(options = {})

This API method deletes a db security group

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_security_group_name (String)

    is the name of the db security group to be deleted (nil)

Raises:



166
167
168
169
170
171
172
173
# File 'lib/AWS/RDS/rds.rb', line 166

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

- (Object) delete_db_snapshot(options = {})

This API method deletes a db snapshot

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_snapshot_identifier (String)

    is the name of the db snapshot to be deleted (nil)

Raises:



179
180
181
182
183
184
185
186
# File 'lib/AWS/RDS/rds.rb', line 179

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

- (Object) describe_db_instances(options = {})

This API method describes the db instances

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_instance_identifier (String)

    if passed, only the description for the db instance matching this identifier is returned

  • :max_records (String)

    is the maximum number of records to include in the response

  • :marker (String)

    provided in the previous request



194
195
196
197
198
199
200
201
# File 'lib/AWS/RDS/rds.rb', line 194

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

- (Object) describe_db_parameter_groups(options = {})

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.

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_parameter_group_name (String)

    is the name of the parameter group

  • :max_records (String)

    is the maximum number of records to include in the response

  • :marker (String)

    provided in the previous request



228
229
230
231
232
233
234
235
# File 'lib/AWS/RDS/rds.rb', line 228

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

- (Object) describe_db_parameters(options = {})

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.

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_parameter_group_name (String)

    is the name parameter group

  • :source (String)

    is the type of parameter to return

  • :max_records (String)

    is the maximum number of records to include in the response

  • :marker (String)

    provided in the previous request

Raises:



246
247
248
249
250
251
252
253
254
255
256
# File 'lib/AWS/RDS/rds.rb', line 246

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

- (Object) describe_db_security_groups(options = {})

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.

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_security_group_name (String)

    is the name of the security group

  • :max_records (String)

    is the maximum number of records to include in the response

  • :marker (String)

    provided in the previous request



266
267
268
269
270
271
272
273
# File 'lib/AWS/RDS/rds.rb', line 266

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

- (Object) describe_db_snapshots(options = {})

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.

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_instance_identifier (String)

    is the unique identifier that identifies a DB instance

  • :db_snapshot_identifier (String)

    is a unique identifier for an amazon RDS snapshot

  • :max_records (String)

    is the maximum number of records to include in the response

  • :marker (String)

    provided in the previous request

Raises:



287
288
289
290
291
292
293
294
295
296
297
298
# File 'lib/AWS/RDS/rds.rb', line 287

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

- (Object) describe_engine_default_parameters(options = {})

This API method describes the default engine parameters

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :engine (String)

    is the name of the database engine

  • :max_records (String)

    is the maximum number of records to include in the response

  • :marker (String)

    provided in the previous request

Raises:



209
210
211
212
213
214
215
216
217
218
# File 'lib/AWS/RDS/rds.rb', line 209

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

- (Object) describe_events(options = {})

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.

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :source_identifier (String)

    is the identifier for the source for which events will be included

  • :source_type (String)

    is the type of event sources to return

  • :start_time (String)

    is the beginning of the time interval to return records for (ISO 8601 format)

  • :end_time (String)

    is the end of the time interval to return records (ISO 8601 format)

  • :duration (String)

    is the number of minutes to return events for.

  • :max_records (String)

    is the maximum number of records to include in the response

  • :marker (String)

    provided in the previous request



316
317
318
319
320
321
322
323
324
325
326
327
# File 'lib/AWS/RDS/rds.rb', line 316

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

- (Object) modify_db_instance(options = {})

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.

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_instance_identifier (String) — default: nil

    the name of the db_instance

  • :allocated_storage (String)

    in gigabytes (nil)

  • :db_instance_class (String)

    in contains compute and memory capacity (nil)

  • :engine (String)

    type i.e. MySQL5.1 (nil)

  • :master_username (String)

    is the master username for the db instance (nil)

  • :master_user_password (String)

    is the master password for the db instance (nil)

  • :port (String)

    is the port the database accepts connections on (3306)

  • :db_name (String)

    contains the name of the database to create when created (nil)

  • :db_parameter_group_name (String)

    is the database parameter group to associate with this instance (nil)

  • :db_security_groups (Array)

    are the list of db security groups to associate with the instance (nil)

  • :availability_zone (String)

    is the availability_zone to create the instance in (nil)

  • :preferred_maintenance_window (String)

    in format: ddd:hh24:mi-ddd:hh24:mi (nil)

  • :backup_retention_period (String)

    is the number of days which automated backups are retained (1)

  • :preferred_backup_window (String)

    is the daily time range for which automated backups are created

Raises:



353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
# File 'lib/AWS/RDS/rds.rb', line 353

def modify_db_instance( options = {})
  raise ArgumentError, "No :db_instance_identifier provided" if options.does_not_have?(:db_instance_identifier)

  # handle a former argument that was misspelled
  raise ArgumentError, "Perhaps you meant :backup_retention_period" if options.has?(:backend_retention_period)

  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.merge!(pathlist("DBSecurityGroups.member", [options[:db_security_groups]].flatten)) if options.has_key?(:db_security_groups)
  params["AvailabilityZone"] = options[:availability_zone] if options.has?(:availability_zone)
  params["PreferredMaintenanceWindow"] = options[:preferred_maintenance_window] if options.has?(:preferred_maintenance_window)
  params["BackupRetentionPeriod"] = options[:backup_retention_period].to_s if options.has?(:backup_retention_period)
  params["PreferredBackupWindow"] = options[:preferred_backup_window] if options.has?(:preferred_backup_window)

  return response_generator(:action => "ModifyDBInstance", :params => params)
end

- (Object) modify_db_parameter_group(options = {})

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.

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_parameter_group_name (String)

    is the name of the parameter group to modify

  • :parameters (String)

    is the array of parameters to update in a hash format => “ParameterName”, :value => “ParameterValue”, :apply_method => “pending-reboot”

Raises:



387
388
389
390
391
392
393
394
395
396
397
398
399
400
# File 'lib/AWS/RDS/rds.rb', line 387

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

- (Object) reboot_db_instance(options = {})

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.

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_instance_identifier (String)

    is the identifier for the db instance to restart

Raises:



407
408
409
410
411
412
413
414
# File 'lib/AWS/RDS/rds.rb', line 407

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

- (Object) reset_db_parameter_group(options = {})

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.

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_parameter_group_name (String)

    is the name of the parameter group to modify

  • :reset_all_parameters (String)

    specified whether to reset all the db parameters

  • :parameters (String)

    is the array of parameters to update in a hash format => “ParameterName”, :apply_method => “pending-reboot”

Raises:



425
426
427
428
429
430
431
432
433
434
435
436
437
438
# File 'lib/AWS/RDS/rds.rb', line 425

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

- (Object) restore_db_instance_from_snapshot(options = {})

This API method restores a db instance to a snapshot of the instance

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_snapshot_identifier (String)

    is the db identifier of the snapshot to restore from

  • :db_instance_identifier (String)

    is the identifier of the db instance

  • :db_instance_class (String)

    is the class of db compute and memory instance for the db instance

  • :port (String)

    is the port which the db can accept connections on

  • :availability_zone (String)

    is the EC2 zone which the db instance will be created

Raises:



448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
# File 'lib/AWS/RDS/rds.rb', line 448

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

- (Object) restore_db_instance_to_point_in_time(options = {})

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.

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :source_db_instance_identifier (String)

    the identifier of the source DB Instance from which to restore.

  • :use_latest_restorable_time (optional, Boolean)

    specifies that the db be restored to the latest restored time. Conditional, cannot be specified if :restore_time parameter is provided.

  • :restore_time (optional, Date)

    specifies the date and time to restore from. Conditional, cannot be specified if :use_latest_restorable_time parameter is true.

  • :target_db_instance_identifier (String)

    is the name of the new database instance to be created.

  • :db_instance_class (optional, String)

    specifies the class of the compute and memory of the EC2 instance, Options : db.m1.small | db.m1.large | db.m1.xlarge | db.m2.2xlarge | db.m2.4xlarge | db.cc1.4xlarge

  • :port (optional, Integer)

    is the port which the db can accept connections on. Constraints: Value must be 1115-65535

  • :availability_zone (optional, String)

    is the EC2 zone which the db instance will be created

Raises:



478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
# File 'lib/AWS/RDS/rds.rb', line 478

def restore_db_instance_to_point_in_time( options = {} )
  raise ArgumentError, "No :source_db_instance_identifier provided" if options.does_not_have?(:source_db_instance_identifier)
  raise ArgumentError, "No :target_db_instance_identifier provided" if options.does_not_have?(:target_db_instance_identifier)

  params = {}
  params['SourceDBInstanceIdentifier'] = options[:source_db_instance_identifier]
  params['TargetDBInstanceIdentifier'] = options[:target_db_instance_identifier]

  if options.has?(:use_latest_restorable_time) && options.has?(:restore_time)
    raise ArgumentError, "You cannot provide both :use_latest_restorable_time and :restore_time"
  elsif options.has?(:use_latest_restorable_time)
    params['UseLatestRestorableTime'] = case options[:use_latest_restorable_time]
                                        when 'true', 'false'
                                          options[:use_latest_restorable_time]
                                        when true
                                          'true'
                                        when false
                                          'false'
                                        else
                                          raise ArgumentError, "Invalid value provided for :use_latest_restorable_time.  Expected boolean."
                                        end
  elsif options.has?(: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

- (Object) revoke_db_security_group(options = {})

This API method authorizes network ingress for an amazon ec2 group

Parameters:

  • options (Hash) (defaults to: {})

    a customizable set of options

Options Hash (options):

  • :db_security_group_name (String)

    is the name of the db security group

  • :cidrip (String)

    is the network ip to revoke

  • :ec2_security_group_name (String)

    is the name of the ec2 security group to authorize

  • :ec2_security_group_owner_id (String)

    is the owner id of the security group

Raises:



517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
# File 'lib/AWS/RDS/rds.rb', line 517

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