Class: Fog::AWS::RDS::Mock

Inherits:
Object
  • Object
show all
Defined in:
lib/fog/aws/rds.rb,
lib/fog/aws/requests/rds/describe_events.rb,
lib/fog/aws/requests/rds/create_db_instance.rb,
lib/fog/aws/requests/rds/delete_db_instance.rb,
lib/fog/aws/requests/rds/create_db_snapshot.rb,
lib/fog/aws/requests/rds/modify_db_instance.rb,
lib/fog/aws/requests/rds/delete_db_snapshot.rb,
lib/fog/aws/requests/rds/reboot_db_instance.rb,
lib/fog/aws/requests/rds/promote_read_replica.rb,
lib/fog/aws/requests/rds/add_tags_to_resource.rb,
lib/fog/aws/requests/rds/describe_db_log_files.rb,
lib/fog/aws/requests/rds/describe_db_instances.rb,
lib/fog/aws/requests/rds/describe_db_snapshots.rb,
lib/fog/aws/requests/rds/create_db_subnet_group.rb,
lib/fog/aws/requests/rds/describe_db_parameters.rb,
lib/fog/aws/requests/rds/delete_db_subnet_group.rb,
lib/fog/aws/requests/rds/list_tags_for_resource.rb,
lib/fog/aws/requests/rds/delete_db_security_group.rb,
lib/fog/aws/requests/rds/create_db_security_group.rb,
lib/fog/aws/requests/rds/delete_db_parameter_group.rb,
lib/fog/aws/requests/rds/modify_db_parameter_group.rb,
lib/fog/aws/requests/rds/describe_db_subnet_groups.rb,
lib/fog/aws/requests/rds/create_db_parameter_group.rb,
lib/fog/aws/requests/rds/remove_tags_from_resource.rb,
lib/fog/aws/requests/rds/download_db_logfile_portion.rb,
lib/fog/aws/requests/rds/describe_db_engine_versions.rb,
lib/fog/aws/requests/rds/describe_db_security_groups.rb,
lib/fog/aws/requests/rds/describe_db_parameter_groups.rb,
lib/fog/aws/requests/rds/describe_db_reserved_instances.rb,
lib/fog/aws/requests/rds/create_db_instance_read_replica.rb,
lib/fog/aws/requests/rds/revoke_db_security_group_ingress.rb,
lib/fog/aws/requests/rds/authorize_db_security_group_ingress.rb,
lib/fog/aws/requests/rds/restore_db_instance_to_point_in_time.rb,
lib/fog/aws/requests/rds/restore_db_instance_from_db_snapshot.rb,
lib/fog/aws/requests/rds/describe_orderable_db_instance_options.rb

Class Method Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (Mock) initialize(options = {})



114
115
116
117
118
119
120
121
# File 'lib/fog/aws/rds.rb', line 114

def initialize(options={})
  @use_iam_profile = options[:use_iam_profile]
  @region = options[:region] || 'us-east-1'

  unless ['ap-northeast-1', 'ap-southeast-1', 'ap-southeast-2', 'eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2', 'sa-east-1'].include?(@region)
    raise ArgumentError, "Unknown region: #{@region.inspect}"
  end
end

Class Method Details

+ (Object) data



88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
# File 'lib/fog/aws/rds.rb', line 88

def self.data
  @data ||= Hash.new do |hash, region|
    hash[region] = Hash.new do |region_hash, key|
      region_hash[key] = {
        :servers => {},
        :security_groups => {},
        :subnet_groups => {},
        :snapshots => {},
        :parameter_groups => {"default.mysql5.1" => { "DBParameterGroupFamily"=>"mysql5.1",
                                                      "Description"=>"Default parameter group for mysql5.1",
                                                      "DBParameterGroupName"=>"default.mysql5.1"
                                                    },
                              "default.mysql5.5" => {"DBParameterGroupFamily"=>"mysql5.5",
                                                    "Description"=>"Default parameter group for mysql5.5",
                                                    "DBParameterGroupName"=>"default.mysql5.5"
                                                    }
                              }
                         }
    end
  end
end

+ (Object) reset



110
111
112
# File 'lib/fog/aws/rds.rb', line 110

def self.reset
  @data = nil
end

Instance Method Details

- (Object) add_tags_to_resource(rds_id, tags)



26
27
28
29
30
31
32
33
34
35
36
37
38
# File 'lib/fog/aws/requests/rds/add_tags_to_resource.rb', line 26

def add_tags_to_resource(rds_id, tags)
  response = Excon::Response.new
  if server = self.data[:servers][rds_id]
    self.data[:tags][rds_id].merge! tags
    response.status = 200
    response.body = {
      "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id }
    }
    response
  else
    raise Fog::AWS::RDS::NotFound.new("DBInstance #{rds_id} not found")
  end
end

- (Object) authorize_db_security_group_ingress(name, opts = {})



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
# File 'lib/fog/aws/requests/rds/authorize_db_security_group_ingress.rb', line 31

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'].find{|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'].find{|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

- (Object) create_db_instance(db_name, options = {})



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
# File 'lib/fog/aws/requests/rds/create_db_instance.rb', line 53

def create_db_instance(db_name, options={})
  response = Excon::Response.new
  if self.data[:servers] and self.data[:servers][db_name]
    # I don't know how to raise an exception that contains the excon data
    #response.status = 400
    #response.body = {
    #  'Code' => 'DBInstanceAlreadyExists',
    #  'Message' => "DB Instance already exists"
    #}
    #return response
    raise Fog::AWS::RDS::IdentifierTaken.new("DBInstanceAlreadyExists #{response.body.to_s}")
  end

  # These are the required parameters according to the API
  required_params = %w{AllocatedStorage DBInstanceClass Engine MasterUserPassword MasterUsername }
  required_params.each do |key|
    unless options.key?(key) and options[key] and !options[key].to_s.empty?
      #response.status = 400
      #response.body = {
      #  'Code' => 'MissingParameter',
      #  'Message' => "The request must contain the parameter #{key}"
      #}
      #return response
      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"=>[],
         "PreferredMaintenanceWindow"=>"mon:04:30-mon:05:00",
         "Engine"=> options["Engine"],
         "EngineVersion"=> options["EngineVersion"] || "5.5.12",
         "PendingModifiedValues"=>{"MasterUserPassword"=>"****"}, # This clears when is available
         "MultiAZ"=> !!options['MultiAZ'],
         "MasterUsername"=> options["MasterUsername"],
         "DBInstanceClass"=> options["DBInstanceClass"],
         "DBInstanceStatus"=>"creating",
         "BackupRetentionPeriod"=> options["BackupRetentionPeriod"] || 1,
         "AllocatedStorage"=> options["AllocatedStorage"],
         "Iops" => options["Iops"],
         "DBParameterGroups"=> # I think groups should be in the self.data method
                  [{"DBParameterGroupName"=>"default.mysql5.5",
                    "ParameterApplyStatus"=>"in-sync"}],
         "DBSecurityGroups"=>
                  [{"Status"=>"active",
                    "DBSecurityGroupName"=>"default"}],
         "LicenseModel"=>"general-public-license",
         "PreferredBackupWindow"=>"08:00-08:30",
#                 "ReadReplicaSourceDBInstanceIdentifier" => nil,
#                 "LatestRestorableTime" => nil,
         "AvailabilityZone" => options["AvailabilityZone"],
         "DBSubnetGroupName" => options["DBSubnetGroupName"],
         "PubliclyAccessible" => options["PubliclyAccessible"],
         "VpcSecurityGroups" => options["VpcSecurityGroups"],
     }

  self.data[:servers][db_name] = data
  response.body = {
    "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
    "CreateDBInstanceResult"=> {"DBInstance"=> data}
  }
  response.status = 200
  # This values aren't showed at creating time but at available time
  self.data[:servers][db_name]["InstanceCreateTime"] = Time.now
  self.data[:tags] ||= {}
  self.data[:tags][db_name] = {}
  response
end

- (Object) create_db_instance_read_replica(instance_identifier, source_identifier, options = {})



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
65
66
67
68
69
70
71
72
73
# File 'lib/fog/aws/requests/rds/create_db_instance_read_replica.rb', line 30

def create_db_instance_read_replica(instance_identifier, source_identifier, options={})
  # TODO: throw error when instance_identifier already exists,
  # or source_identifier doesn't exist

  source = self.data[:servers][source_identifier]
  data = {
    'AllocatedStorage' => source['AllocatedStorage'],
    'AutoMinorVersionUpgrade' => options.key?('AutoMinorVersionUpgrade') ? options['AutoMinorVersionUpgrade'] : true,
    'AvailabilityZone' => options['AvailabilityZone'],
    'DBInstanceClass' => options['DBInstanceClass'] || 'db.m1.small',
    'DBInstanceIdentifier' => instance_identifier,
    'DBInstanceStatus' => 'creating',
    'DBName' => source['DBName'],
    'DBParameterGroups' => source['DBParameterGroups'],
    'DBSecurityGroups' => source['DBSecurityGroups'],
    'Endpoint' => {},
    'Engine' => source['Engine'],
    'EngineVersion' => options['EngineVersion'] || '5.5.12',
    'InstanceCreateTime' => nil,
    'Iops' => source['Iops'],
    'LatestRestorableTime' => nil,
    'LicenseModel' => 'general-public-license',
    'MasterUsername' => source['MasterUsername'],
    'MultiAZ' => false,
    'PendingModifiedValues' => {},
    'PreferredBackupWindow'=> '08:00-08:30',
    'PreferredMaintenanceWindow'=> "mon:04:30-mon:05:00",
    'ReadReplicaDBInstanceIdentifiers'=> [],
    'ReadReplicaSourceDBInstanceIdentifier'=> source_identifier
  }
  self.data[:servers][instance_identifier] = data
  self.data[:servers][source_identifier]['ReadReplicaDBInstanceIdentifiers'] << instance_identifier

  response = Excon::Response.new
  response.body = {
    "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
    "CreateDBInstanceReadReplicaResult"=> {"DBInstance"=> data}
  }
  response.status = 200
  # This values aren't showed at creating time but at available time
  self.data[:servers][instance_identifier]["InstanceCreateTime"] = Time.now

  response
end

- (Object) create_db_parameter_group(group_name, group_family, description)



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
# File 'lib/fog/aws/requests/rds/create_db_parameter_group.rb', line 30

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

- (Object) create_db_security_group(name, description = name)



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# File 'lib/fog/aws/requests/rds/create_db_security_group.rb', line 26

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

- (Object) create_db_snapshot(identifier, name)



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
54
55
56
57
58
59
60
61
62
63
64
# File 'lib/fog/aws/requests/rds/create_db_snapshot.rb', line 26

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

  # TODO: raise an error if the server isn't in 'available' state

  snapshot_data = {
    'Status'               => 'creating',
    'SnapshotType'         => 'manual',
    'DBInstanceIdentifier' => identifier,
    'DBSnapshotIdentifier' => name,
    'InstanceCreateTime'   => Time.now
  }
  # Copy attributes from server
  %w(Engine EngineVersion AvailabilityZone AllocatedStorage Iops 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

  # TODO: put the server in 'modifying' state

  response.body = {
    "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
    "CreateDBSnapshotResult"=> {"DBSnapshot"=> snapshot_data.dup}
  }
  response.status = 200
  # SnapshotCreateTime is not part of the response.
  self.data[:snapshots][name]['SnapshotCreateTime'] = Time.now
  response
end

- (Object) create_db_subnet_group(name, subnet_ids, description = name)



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
54
55
56
57
# File 'lib/fog/aws/requests/rds/create_db_subnet_group.rb', line 27

def create_db_subnet_group(name, subnet_ids, description = name)
  response = Excon::Response.new
  if self.data[:subnet_groups] && self.data[:subnet_groups][name]
    raise Fog::AWS::RDS::IdentifierTaken.new("DBSubnetGroupAlreadyExists => The subnet group '#{name}' already exists")
  end

  # collection = Fog::Compute::AWS.new(:aws_access_key_id => 'mock key', :aws_secret_access_key => 'mock secret')
  collection = Fog::Compute[:aws]
  collection.region = @region

  subnets = subnet_ids.map do |snid|
    subnet = collection.subnets.get(snid)
    raise Fog::AWS::RDS::NotFound.new("InvalidSubnet => The subnet '#{snid}' was not found") if subnet.nil?
    subnet
  end
  vpc_id = subnets.first.vpc_id

  data = {
    'DBSubnetGroupName' => name,
    'DBSubnetGroupDescription' => description,
    'SubnetGroupStatus' => 'Complete',
    'Subnets' => subnet_ids,
    'VpcId' => vpc_id
  }
  self.data[:subnet_groups][name] = data
  response.body = {
    "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
    'CreateDBSubnetGroupResult' => { 'DBSubnetGroup' => data }
  }
  response
end

- (Object) data



123
124
125
# File 'lib/fog/aws/rds.rb', line 123

def data
  self.class.data[@region][@aws_access_key_id]
end

- (Object) delete_db_instance(identifier, snapshot_identifier, skip_snapshot = false)



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
# File 'lib/fog/aws/requests/rds/delete_db_instance.rb', line 30

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

- (Object) delete_db_parameter_group(group_name)



25
26
27
28
29
30
31
32
33
34
35
36
37
# File 'lib/fog/aws/requests/rds/delete_db_parameter_group.rb', line 25

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

- (Object) delete_db_security_group(name, description = name)



24
25
26
27
28
29
30
31
32
33
34
35
36
# File 'lib/fog/aws/requests/rds/delete_db_security_group.rb', line 24

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

- (Object) delete_db_snapshot(name)

Raises:

  • (Fog::AWS::RDS::NotFound)


25
26
27
28
29
30
31
32
33
34
35
36
37
38
# File 'lib/fog/aws/requests/rds/delete_db_snapshot.rb', line 25

def delete_db_snapshot(name)
  # TODO: raise error if snapshot isn't 'available'
  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

- (Object) delete_db_subnet_group(name)



23
24
25
26
27
28
29
30
31
32
33
34
# File 'lib/fog/aws/requests/rds/delete_db_subnet_group.rb', line 23

def delete_db_subnet_group(name)
  response = Excon::Response.new
  unless self.data[:subnet_groups] && self.data[:subnet_groups][name]
    raise Fog::AWS::RDS::NotFound.new("DBSubnetGroupNotFound => The subnet group '#{name}' doesn't exists")
  end

  response.body = {
    'ResponseMetadata'=>{ 'RequestId'=> Fog::AWS::Mock.request_id },
    'return' => true,
  }
  response
end

- (Object) describe_db_engine_versions(opts = {})



24
25
26
# File 'lib/fog/aws/requests/rds/describe_db_engine_versions.rb', line 24

def describe_db_engine_versions(opts={})
  Fog::Mock.not_implemented
end

- (Object) describe_db_instances(identifier = nil, opts = {})



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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
# File 'lib/fog/aws/requests/rds/describe_db_instances.rb', line 32

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 Time.now - self.data[:reboot_time] >= Fog::Mock.delay
          # apply pending modified values
          server.merge!(server["PendingModifiedValues"])
          server["PendingModifiedValues"] = {}

          server["DBInstanceStatus"] = 'available'
          self.data.delete(:reboot_time)
        end
      when "modifying"
        # TODO there are some fields that only applied after rebooting
        if Time.now - self.data[:modify_time] >= Fog::Mock.delay
          server.merge!(server["PendingModifiedValues"])
          server["PendingModifiedValues"] = {}
          server["DBInstanceStatus"] = 'available'
        end
      when "available" # I'm not sure if amazon does this
        unless server["PendingModifiedValues"].empty?
          server["DBInstanceStatus"] = 'modifying'
        end
     end
  end

  response.status = 200
  response.body = {
    "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
    "DescribeDBInstancesResult" => { "DBInstances" => server_set }
  }
  response
end

- (Object) describe_db_log_files(rds_id = nil, opts = {})



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
# File 'lib/fog/aws/requests/rds/describe_db_log_files.rb', line 37

def describe_db_log_files(rds_id=nil, opts={})
  response = Excon::Response.new
  log_file_set = []

  if rds_id
    if server = self.data[:servers][rds_id]
      log_file_set << {"LastWritten" => Time.parse('2013-07-05 17:00:00 -0700'), "LogFileName" => "error/mysql-error.log", "Size" => 0}
      log_file_set << {"LastWritten" => Time.parse('2013-07-05 17:10:00 -0700'), "LogFileName" => "error/mysql-error-running.log", "Size" => 0}
      log_file_set << {"LastWritten" => Time.parse('2013-07-05 17:20:00 -0700'), "LogFileName" => "error/mysql-error-running.log.0", "Size" => 8220}
      log_file_set << {"LastWritten" => Time.parse('2013-07-05 17:30:00 -0700'), "LogFileName" => "error/mysql-error-running.log.1", "Size" => 0}
    else
      raise Fog::AWS::RDS::NotFound.new("DBInstance #{rds_id} not found")
    end
  else
    raise Fog::AWS::RDS::NotFound.new('An identifier for an RDS instance must be provided')
  end

  response.status = 200
  response.body = {
      "ResponseMetadata" => { "RequestId" => Fog::AWS::Mock.request_id },
      "DescribeDBLogFilesResult" => { "DBLogFiles" => log_file_set }
  }
  response
end

- (Object) describe_db_parameter_groups(name = nil, opts = {})



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
# File 'lib/fog/aws/requests/rds/describe_db_parameter_groups.rb', line 35

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

- (Object) describe_db_parameters(name, opts = {})



36
37
38
# File 'lib/fog/aws/requests/rds/describe_db_parameters.rb', line 36

def describe_db_parameters(name, opts={})
  Fog::Mock.not_implemented
end

- (Object) describe_db_reserved_instances(identifier = nil, opts = {})



32
33
34
# File 'lib/fog/aws/requests/rds/describe_db_reserved_instances.rb', line 32

def describe_db_reserved_instances(identifier=nil, opts={})
  Fog::Mock.not_implemented
end

- (Object) describe_db_security_groups(opts = {})



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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
# File 'lib/fog/aws/requests/rds/describe_db_security_groups.rb', line 28

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

  # TODO: refactor to not delete items that we're iterating over. Causes
  # model tests to fail (currently pending)
  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

    # TODO: refactor to not delete items that we're iterating over. Causes
    # model tests to fail (currently pending)
    sec_group["EC2SecurityGroups"].each do |ec2_secg|
      if ec2_secg["Status"] == "authorizing" || ec2_secg["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

- (Object) describe_db_snapshots(opts = {})



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
# File 'lib/fog/aws/requests/rds/describe_db_snapshots.rb', line 34

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

  # Build response
  response.status = 200
  response.body = {
    "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
    "DescribeDBSnapshotsResult" => { "DBSnapshots" => snapshots }
  }
  response
end

- (Object) describe_db_subnet_groups(name = nil, opts = {})



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
# File 'lib/fog/aws/requests/rds/describe_db_subnet_groups.rb', line 35

def describe_db_subnet_groups(name = nil, opts = {})
  response = Excon::Response.new

  subnet_group_set = []
  if name
    if subnet_group = self.data[:subnet_groups][name]
      subnet_group_set << subnet_group
    else
      raise Fog::AWS::RDS::NotFound.new("Subnet Group #{name} not found")
    end
  else
    subnet_group_set = self.data[:subnet_groups].values
  end

  response.status = 200
  response.body = {
    "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
    "DescribeDBSubnetGroupsResult" => { "DBSubnetGroups" => subnet_group_set }
  }
  response
end

- (Object) describe_events



44
45
46
# File 'lib/fog/aws/requests/rds/describe_events.rb', line 44

def describe_events
  Fog::Mock.not_implemented
end

- (Object) describe_orderable_db_instance_options(engine = nil, opts = {})



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
65
66
67
68
# File 'lib/fog/aws/requests/rds/describe_orderable_db_instance_options.rb', line 39

def describe_orderable_db_instance_options(engine=nil, opts={})
  instance_options = []
  response = Excon::Response.new
  if engine
    (opts[:db_instance_class] || %w(db.m2.xlarge db.m1.large)).each do |size|
      instance_options << {'MultiAZCapable' => true,
                           'Engine' => engine,
                           'LicenseModel' => opts[:license_model] || 'general-public-license',
                           'ReadReplicaCapable' => true,
                           'EngineVersion' => opts[:engine_version] || '5.6.12',
                           'AvailabilityZones' => [
                              {'Name' => 'us-east-1b', 'ProvisionedIopsCapable' => true},
                              {'Name' => 'us-east-1c', 'ProvisionedIopsCapable' => true},
                              {'Name' => 'us-east-1d', 'ProvisionedIopsCapable' => false},
                              {'Name' => 'us-east-1e', 'ProvisionedIopsCapable' => true}],
                           'DBInstanceClass' => size,
                           'Vpc' => opts[:vpc].nil? ? true : opts[:vpc]}

    end
  else
    raise Fog::AWS::RDS::NotFound.new('An engine must be specified to retrieve orderable instance options')
  end

  response.status = 200
  response.body = {
      'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id },
      'DescribeOrderableDBInstanceOptionsResult' => { 'OrderableDBInstanceOptions' => instance_options }
  }
  response
end

- (Object) download_db_logfile_portion(identifier = nil, filename = nil, opts = {})



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
# File 'lib/fog/aws/requests/rds/download_db_logfile_portion.rb', line 35

def download_db_logfile_portion(identifier=nil, filename=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

  response.status = 200
  response.body = {
      "ResponseMetadata" => { "RequestId"=> Fog::AWS::Mock.request_id },
      "DescribeDBInstancesResult" => { "DBInstances" => server_set }
  }
  response
end

- (Object) list_tags_for_resource(rds_id)



24
25
26
27
28
29
30
31
32
33
34
35
36
# File 'lib/fog/aws/requests/rds/list_tags_for_resource.rb', line 24

def list_tags_for_resource(rds_id)
  response = Excon::Response.new
  if server = self.data[:servers][rds_id]
    response.status = 200
    response.body = {
      "ListTagsForResourceResult" =>
        {"TagList" =>  self.data[:tags][rds_id]}
    }
    response
  else
    raise Fog::AWS::RDS::NotFound.new("DBInstance #{rds_id} not found")
  end
end

- (Object) modify_db_instance(db_name, apply_immediately, options = {})



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
# File 'lib/fog/aws/requests/rds/modify_db_instance.rb', line 49

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[:modify_time] = Time.now
      # TODO verify the params options
      # if apply_immediately is false, all the options go to pending_modified_values and then apply and clear after either
      # a reboot or the maintainance window
      #if apply_immediately
      #  modified_server = server.merge(options)
      #else
      #  modified_server = server["PendingModifiedValues"].merge!(options) # it appends
      #end
      self.data[:servers][db_name]["PendingModifiedValues"].merge!(options) # it appends
      self.data[:servers][db_name]["DBInstanceStatus"] = "modifying"
      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

- (Object) modify_db_parameter_group(group_name, parameters)



44
45
46
# File 'lib/fog/aws/requests/rds/modify_db_parameter_group.rb', line 44

def modify_db_parameter_group(group_name, parameters)
  Fog::Mock.not_implemented
end

- (Object) promote_read_replica(identifier, backup_retention_period = nil, preferred_backup_window = nil)



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
# File 'lib/fog/aws/requests/rds/promote_read_replica.rb', line 36

def promote_read_replica(identifier, backup_retention_period = nil, preferred_backup_window = nil)
  if self.data[:servers][identifier]
    data = {
        'BackupRetentionPeriod' => backup_retention_period || 1,
        'PreferredBackupWindow' => preferred_backup_window || '08:00-08:30',
        'DBInstanceIdentifier' => identifier
    }
    self.data[:servers][identifier].merge(data)

    response = Excon::Response.new
    response.body = {
        "ResponseMetadata" => { "RequestId" => Fog::AWS::Mock.request_id },
        "PromoteReadReplicaResult" => { "DBInstance" => data}
    }
    response.status = 200
    response
  else
    raise Fog::AWS::RDS::NotFound.new("DBInstance #{identifier} not found")
  end
end

- (Object) reboot_db_instance(instance_identifier)



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# File 'lib/fog/aws/requests/rds/reboot_db_instance.rb', line 24

def reboot_db_instance(instance_identifier)
  response = Excon::Response.new
  if server = self.data[:servers][instance_identifier]
    if server["DBInstanceStatus"] != "available"
      raise Fog::AWS::RDS::NotFound.new("DBInstance #{instance_identifier} not available for rebooting")
    else
      server["DBInstanceStatus"] = 'rebooting'
      self.data[:reboot_time] = Time.now
      response.status = 200
      response.body = {
        "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        "RebootDBInstanceResult" => { "DBInstance" => server }
      }
      response

    end
  else
    raise Fog::AWS::RDS::NotFound.new("DBInstance #{instance_identifier} not found")
  end
end

- (Object) remove_tags_from_resource(rds_id, keys)



24
25
26
27
28
29
30
31
32
33
34
35
36
# File 'lib/fog/aws/requests/rds/remove_tags_from_resource.rb', line 24

def remove_tags_from_resource(rds_id, keys)
  response = Excon::Response.new
  if server = self.data[:servers][rds_id]
    keys.each {|key| self.data[:tags][rds_id].delete key}
    response.status = 200
    response.body = {
      "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id }
    }
    response
  else
    raise Fog::AWS::RDS::NotFound.new("DBInstance #{rds_id} not found")
  end
end

- (Object) reset_data



127
128
129
# File 'lib/fog/aws/rds.rb', line 127

def reset_data
  self.class.data[@region].delete(@aws_access_key_id)
end

- (Object) restore_db_instance_from_db_snapshot(snapshot_id, db_id, options = {})



23
24
25
# File 'lib/fog/aws/requests/rds/restore_db_instance_from_db_snapshot.rb', line 23

def restore_db_instance_from_db_snapshot(snapshot_id, db_id, options={})
  Fog::Mock.not_implemented
end

- (Object) restore_db_instance_to_point_in_time(source_db_name, target_db_name, opts = {})



23
24
25
# File 'lib/fog/aws/requests/rds/restore_db_instance_to_point_in_time.rb', line 23

def restore_db_instance_to_point_in_time(source_db_name, target_db_name, opts={})
  Fog::Mock.not_implemented
end

- (Object) revoke_db_security_group_ingress(name, opts = {})



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
# File 'lib/fog/aws/requests/rds/revoke_db_security_group_ingress.rb', line 31

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

- (Object) setup_credentials(options)



131
132
133
# File 'lib/fog/aws/rds.rb', line 131

def setup_credentials(options)
  @aws_access_key_id = options[:aws_access_key_id]
end