authorize_db_security_group_ingress(name, opts = {})
click to toggle source
def authorize_db_security_group_ingress(name, opts = {})
unless opts.key?('CIDRIP') || (opts.key?('EC2SecurityGroupName') && opts.key?('EC2SecurityGroupOwnerId'))
raise ArgumentError, 'Must specify CIDRIP, or both EC2SecurityGroupName and EC2SecurityGroupOwnerId'
end
response = Excon::Response.new
if sec_group = self.data[:security_groups][name]
if opts.key?('CIDRIP')
if sec_group['IPRanges'].detect{|h| h['CIDRIP'] == opts['CIDRIP']}
raise Fog::AWS::RDS::AuthorizationAlreadyExists.new("AuthorizationAlreadyExists => #{opts['CIDRIP']} is alreay defined")
end
sec_group['IPRanges'] << opts.merge({"Status" => 'authorizing'})
else
if sec_group['EC2SecurityGroups'].detect{|h| h['EC2SecurityGroupName'] == opts['EC2SecurityGroupName']}
raise Fog::AWS::RDS::AuthorizationAlreadyExists.new("AuthorizationAlreadyExists => #{opts['EC2SecurityGroupName']} is alreay defined")
end
sec_group['EC2SecurityGroups'] << opts.merge({"Status" => 'authorizing'})
end
response.status = 200
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
'AuthorizeDBSecurityGroupIngressResult' => {
'DBSecurityGroup' => sec_group
}
}
response
else
raise Fog::AWS::RDS::NotFound.new("DBSecurityGroupNotFound => #{name} not found")
end
end
create_db_instance(db_name, options={})
click to toggle source
def create_db_instance(db_name, options={})
response = Excon::Response.new
if self.data[:servers] and self.data[:servers][db_name]
raise Fog::AWS::RDS::IdentifierTaken.new("DBInstanceAlreadyExists #{response.body.to_s}")
end
required_params = %w{AllocatedStorage DBInstanceClass Engine MasterUserPassword MasterUsername }
required_params.each do |key|
unless options.has_key?(key) and options[key] and !options[key].to_s.empty?
raise Fog::AWS::RDS::NotFound.new("The request must contain the parameter #{key}")
end
end
data =
{
"DBInstanceIdentifier"=> db_name,
"DBName" => options["DBName"],
"InstanceCreateTime" => nil,
"AutoMinorVersionUpgrade"=>true,
"Endpoint"=>{},
"ReadReplicaDBInstanceIdentifiers"=>['bla'],
"PreferredMaintenanceWindow"=>"mon:04:30-mon:05:00",
"Engine"=> options["Engine"],
"EngineVersion"=> options["EngineVersion"] || "5.1.57",
"PendingModifiedValues"=>{"MasterUserPassword"=>"****"},
"MultiAZ"=>false,
"MasterUsername"=> options["MasterUsername"],
"DBInstanceClass"=> options["DBInstanceClass"],
"DBInstanceStatus"=>"creating",
"BackupRetentionPeriod"=> options["BackupRetentionPeriod"] || 1,
"AllocatedStorage"=> options["AllocatedStorage"],
"DBParameterGroups"=>
[{"DBParameterGroupName"=>"default.mysql5.1",
"ParameterApplyStatus"=>"in-sync"}],
"DBSecurityGroups"=>
[{"Status"=>"active",
"DBSecurityGroupName"=>"default"}],
"LicenseModel"=>"general-public-license",
"PreferredBackupWindow"=>"08:00-08:30",
"AvailabilityZone" => options["AvailabilityZone"]
}
self.data[:servers][db_name] = data
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
"CreateDBInstanceResult"=> {"DBInstance"=> data}
}
response.status = 200
self.data[:servers][db_name]["InstanceCreateTime"] = Time.now
response
end
create_db_instance_read_replica(instance_identifier, source_identifier, options={})
click to toggle source
def create_db_instance_read_replica(instance_identifier, source_identifier, options={})
Fog::Mock.not_implemented
end
create_db_parameter_group(group_name, group_family, description)
click to toggle source
def create_db_parameter_group(group_name, group_family, description)
response = Excon::Response.new
if self.data[:parameter_groups] and self.data[:parameter_groups][group_name]
raise Fog::AWS::RDS::IdentifierTaken.new("Parameter group #{group_name} already exists")
end
data = {
'DBParameterGroupName' => group_name,
'DBParameterGroupFamily' => group_family.downcase,
'Description' => description
}
self.data[:parameter_groups][group_name] = data
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
"CreateDBParameterGroupResult"=> {"DBParameterGroup"=> data}
}
response.status = 200
response
end
create_db_security_group(name, description = name)
click to toggle source
def create_db_security_group(name, description = name)
response = Excon::Response.new
if self.data[:security_groups] and self.data[:security_groups][name]
raise Fog::AWS::RDS::IdentifierTaken.new("DBInstanceAlreadyExists => The security group '#{name}' already exists")
end
data = {
'DBSecurityGroupName' => name,
'DBSecurityGroupDescription' => description,
'EC2SecurityGroups' => [],
'IPRanges' => [],
'OwnerId' => '0123456789'
}
self.data[:security_groups][name] = data
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
'CreateDBSecurityGroupResult' => { 'DBSecurityGroup' => data }
}
response
end
create_db_snapshot(identifier, name)
click to toggle source
def create_db_snapshot(identifier, name)
response = Excon::Response.new
if data[:snapshots][name]
raise Fog::AWS::RDS::IndentifierTaken.new
end
server_data = data[:servers][identifier]
unless server_data
raise Fog::AWS::RDS::NotFound.new("DBInstance #{identifier} not found")
end
snapshot_data = {
'Status' => 'creating',
'DBInstanceIdentifier' => identifier,
'DBSnapshotIdentifier' => name,
'InstanceCreateTime' => Time.now
}
%w(Engine EngineVersion AvailabilityZone AllocatedStorage MasterUsername InstanceCreateTime).each do |key|
snapshot_data[key] = server_data[key]
end
snapshot_data['Port'] = server_data['Endpoint']['Port']
self.data[:snapshots][name] = snapshot_data
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
"CreateDBSnapshotResult"=> {"DBSnapshot"=> snapshot_data.dup}
}
response.status = 200
self.data[:snapshots][name]['SnapshotCreateTime'] = Time.now
response
end
data()
click to toggle source
def data
self.class.data[@region][@aws_access_key_id]
end
delete_db_instance(identifier, snapshot_identifier, skip_snapshot = false)
click to toggle source
def delete_db_instance(identifier, snapshot_identifier, skip_snapshot = false)
response = Excon::Response.new
unless skip_snapshot
create_db_snapshot(identifier, snapshot_identifier)
end
if server_set = self.data[:servers].delete(identifier)
response.status = 200
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
"DeleteDBInstanceResult" => { "DBInstance" => server_set }
}
response
else
raise Fog::AWS::RDS::NotFound.new("DBInstance #{identifier} not found")
end
end
delete_db_parameter_group(group_name)
click to toggle source
def delete_db_parameter_group(group_name)
response = Excon::Response.new
if self.data[:parameter_groups].delete(group_name)
response.status = 200
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
}
response
else
raise Fog::AWS::RDS::NotFound.new("DBParameterGroup not found: #{group_name}")
end
end
delete_db_security_group(name, description = name)
click to toggle source
def delete_db_security_group(name, description = name)
response = Excon::Response.new
if self.data[:security_groups].delete(name)
response.status = 200
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
}
response
else
raise Fog::AWS::RDS::NotFound.new("DBSecurityGroupNotFound => #{name} not found")
end
end
delete_db_snapshot(name)
click to toggle source
def delete_db_snapshot(name)
response = Excon::Response.new
snapshot_data = self.data[:snapshots].delete(name)
raise Fog::AWS::RDS::NotFound.new("DBSnapshtoNotFound => #{name} not found") unless snapshot_data
response.status = 200
response.body = {
"ResponseMetadata"=> { "RequestId"=> Fog::AWS::Mock.request_id },
"DeleteDBSnapshotResult"=> {"DBSnapshot"=> snapshot_data}
}
response
end
describe_db_engine_versions(opts={})
click to toggle source
def describe_db_engine_versions(opts={})
Fog::Mock.not_implemented
end
describe_db_instances(identifier=nil, opts={})
click to toggle source
def describe_db_instances(identifier=nil, opts={})
response = Excon::Response.new
server_set = []
if identifier
if server = self.data[:servers][identifier]
server_set << server
else
raise Fog::AWS::RDS::NotFound.new("DBInstance #{identifier} not found")
end
else
server_set = self.data[:servers].values
end
server_set.each do |server|
case server["DBInstanceStatus"]
when "creating"
if Time.now - server['InstanceCreateTime'] >= Fog::Mock.delay * 2
region = "us-east-1"
server["DBInstanceStatus"] = "available"
server["AvailabilityZone"] = region + 'a'
server["Endpoint"] = {"Port"=>3306,
"Address"=> Fog::AWS::Mock.rds_address(server["DBInstanceIdentifier"],region) }
server["PendingModifiedValues"] = {}
end
when "rebooting"
if server["PendingModifiedValues"]
server.merge!(server["PendingModifiedValues"])
server["PendingModifiedValues"] = {}
self.data[:tmp] ||= Time.now + Fog::Mock.delay * 2
if self.data[:tmp] <= Time.now
server["DBInstanceStatus"] = 'available'
self.data.delete(:tmp)
end
end
when "modifying"
if server["PendingModifiedValues"]
server.merge!(server["PendingModifiedValues"])
server["PendingModifiedValues"] = {}
server["DBInstanceStatus"] = 'available'
end
when "available"
if server["PendingModifiedValues"]
server["DBInstanceStatus"] = 'modifying'
end
end
end
response.status = 200
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
"DescribeDBInstancesResult" => { "DBInstances" => server_set }
}
response
end
describe_db_parameter_groups(name=nil, opts={})
click to toggle source
def describe_db_parameter_groups(name=nil, opts={})
response = Excon::Response.new
parameter_set = []
if name
if server = self.data[:parameter_groups][name]
parameter_set << server
else
raise Fog::AWS::RDS::NotFound.new("DBInstance #{name} not found")
end
else
parameter_set = self.data[:parameter_groups].values
end
response.status = 200
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
"DescribeDBParameterGroupsResult" => { "DBParameterGroups" => parameter_set }
}
response
end
describe_db_parameters(name, opts={})
click to toggle source
def describe_db_parameters(name, opts={})
Fog::Mock.not_implemented
end
describe_db_reserved_instances(identifier=nil, opts={})
click to toggle source
def describe_db_reserved_instances(identifier=nil, opts={})
Fog::Mock.not_implemented
end
describe_db_security_groups(opts={})
click to toggle source
def describe_db_security_groups(opts={})
response = Excon::Response.new
sec_group_set = []
if opts.is_a?(String)
sec_group_name = opts
if sec_group = self.data[:security_groups][sec_group_name]
sec_group_set << sec_group
else
raise Fog::AWS::RDS::NotFound.new("Security Group #{sec_group_name} not found")
end
else
sec_group_set = self.data[:security_groups].values
end
sec_group_set.each do |sec_group|
sec_group["IPRanges"].each do |iprange|
if iprange["Status"] == "authorizing" || iprange["Status"] == "revoking"
iprange[:tmp] ||= Time.now + Fog::Mock.delay * 2
if iprange[:tmp] <= Time.now
iprange["Status"] = "authorized" if iprange["Status"] == "authorizing"
iprange.delete(:tmp)
sec_group["IPRanges"].delete(iprange) if iprange["Status"] == "revoking"
end
end
end
sec_group["EC2SecurityGroups"].each do |ec2_secg|
if ec2_secg["Status"] == "authorizing" || iprange["Status"] == "revoking"
ec2_secg[:tmp] ||= Time.now + Fog::Mock.delay * 2
if ec2_secg[:tmp] <= Time.now
ec2_secg["Status"] = "authorized" if ec2_secg["Status"] == "authorizing"
ec2_secg.delete(:tmp)
sec_group["EC2SecurityGroups"].delete(ec2_secg) if ec2_secg["Status"] == "revoking"
end
end
end
end
response.status = 200
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
"DescribeDBSecurityGroupsResult" => { "DBSecurityGroups" => sec_group_set }
}
response
end
describe_db_snapshots(opts={})
click to toggle source
def describe_db_snapshots(opts={})
response = Excon::Response.new
snapshots = self.data[:snapshots].values
if opts[:identifier]
snapshots = snapshots.select{|snapshot| snapshot['DBInstanceIdentifier'] == opts[:identifier]}
end
if opts[:snapshot_id]
snapshots = snapshots.select{|snapshot| snapshot['DBSnapshotIdentifier'] == opts[:snapshot_id]}
raise Fog::AWS::RDS::NotFound.new("DBSnapshot #{opts[:snapshot_id]} not found") if snapshots.empty?
end
snapshots.each do |snapshot|
case snapshot['Status']
when 'creating'
if Time.now - snapshot['SnapshotCreateTime'] > Fog::Mock.delay
snapshot['Status'] = 'available'
end
end
end
response.status = 200
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
"DescribeDBSnapshotsResult" => { "DBSnapshots" => snapshots }
}
response
end
modify_db_instance(db_name, apply_immediately, options={})
click to toggle source
def modify_db_instance(db_name, apply_immediately, options={})
response = Excon::Response.new
if self.data[:servers][db_name]
if self.data[:servers][db_name]["DBInstanceStatus"] != "available"
raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not available for modification")
else
self.data[:servers][db_name]["PendingModifiedValues"].merge!(options)
response.status = 200
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
"ModifyDBInstanceResult" => { "DBInstance" => self.data[:servers][db_name] }
}
response
end
else
raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not found")
end
end
modify_db_parameter_group(group_name, parameters)
click to toggle source
def modify_db_parameter_group(group_name, parameters)
Fog::Mock.not_implemented
end
reboot_db_instance(instance_identifier)
click to toggle source
def reboot_db_instance(instance_identifier)
response = Excon::Response.new
if self.data[:servers][instance_identifier]
if self.data[:servers][instance_identifier]["DBInstanceStatus"] != "available"
raise Fog::AWS::RDS::NotFound.new("DBInstance #{instance_identifier} not available for rebooting")
else
self.data[:servers][instance_identifier]["DBInstanceStatus"] = 'rebooting'
response.status = 200
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
"RebootDBInstanceResult" => { "DBInstance" => self.data[:servers][instance_identifier] }
}
response
end
else
raise Fog::AWS::RDS::NotFound.new("DBInstance #{instance_identifier} not found")
end
end
reset_data()
click to toggle source
def reset_data
self.class.data[@region].delete(@aws_access_key_id)
end
restore_db_instance_from_db_snapshot(snapshot_id, db_id, options={})
click to toggle source
def restore_db_instance_from_db_snapshot(snapshot_id, db_id, options={})
Fog::Mock.not_implemented
end
restore_db_instance_to_point_in_time(source_db_name, target_db_name, opts={})
click to toggle source
def restore_db_instance_to_point_in_time(source_db_name, target_db_name, opts={})
Fog::Mock.not_implemented
end
revoke_db_security_group_ingress(name, opts = {})
click to toggle source
def revoke_db_security_group_ingress(name, opts = {})
unless opts.key?('CIDRIP') || (opts.key?('EC2SecurityGroupName') && opts.key?('EC2SecurityGroupOwnerId'))
raise ArgumentError, 'Must specify CIDRIP, or both EC2SecurityGroupName and EC2SecurityGroupOwnerId'
end
response = Excon::Response.new
if sec_group = self.data[:security_groups][name]
if opts.key?('CIDRIP')
sec_group['IPRanges'].each do |iprange|
iprange['Status']= 'revoking' if iprange['CIDRIP'] == opts['CIDRIP']
end
else
sec_group['EC2SecurityGroups'].each do |ec2_secg|
ec2_secg['Status']= 'revoking' if ec2_secg['EC2SecurityGroupName'] == opts['EC2SecurityGroupName']
end
end
response.status = 200
response.body = {
"ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
'RevokeDBSecurityGroupIngressResult' => {
'DBSecurityGroup' => sec_group
}
}
response
else
raise Fog::AWS::RDS::NotFound.new("DBSecurityGroupNotFound => #{name} not found")
end
end
setup_credentials(options)
click to toggle source
def setup_credentials(options)
@aws_access_key_id = options[:aws_access_key_id]
end