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/create_db_snapshot.rb,
lib/fog/aws/requests/rds/delete_db_instance.rb,
lib/fog/aws/requests/rds/delete_db_snapshot.rb,
lib/fog/aws/requests/rds/modify_db_instance.rb,
lib/fog/aws/requests/rds/reboot_db_instance.rb,
lib/fog/aws/requests/rds/add_tags_to_resource.rb,
lib/fog/aws/requests/rds/promote_read_replica.rb,
lib/fog/aws/requests/rds/describe_db_instances.rb,
lib/fog/aws/requests/rds/describe_db_log_files.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/delete_db_subnet_group.rb,
lib/fog/aws/requests/rds/describe_db_parameters.rb,
lib/fog/aws/requests/rds/list_tags_for_resource.rb,
lib/fog/aws/requests/rds/create_db_security_group.rb,
lib/fog/aws/requests/rds/delete_db_security_group.rb,
lib/fog/aws/requests/rds/create_db_parameter_group.rb,
lib/fog/aws/requests/rds/create_event_subscription.rb,
lib/fog/aws/requests/rds/delete_db_parameter_group.rb,
lib/fog/aws/requests/rds/delete_event_subscription.rb,
lib/fog/aws/requests/rds/describe_db_subnet_groups.rb,
lib/fog/aws/requests/rds/modify_db_parameter_group.rb,
lib/fog/aws/requests/rds/remove_tags_from_resource.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/download_db_logfile_portion.rb,
lib/fog/aws/requests/rds/describe_db_parameter_groups.rb,
lib/fog/aws/requests/rds/describe_event_subscriptions.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_from_db_snapshot.rb,
lib/fog/aws/requests/rds/restore_db_instance_to_point_in_time.rb,
lib/fog/aws/requests/rds/describe_orderable_db_instance_options.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Mock

Returns a new instance of Mock.



142
143
144
145
146
147
148
149
 
# File 'lib/fog/aws/rds.rb', line 142

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

  Fog::AWS.validate_region!(@region)

  setup_credentials(options)
end

Instance Attribute Details

#region ⇒ Object

Returns the value of attribute region.



140
141
142
 
# File 'lib/fog/aws/rds.rb', line 140

def region
  @region
end

Class Method Details

.data ⇒ Object 



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
127
128
129
130
131
132
133
134
 
# File 'lib/fog/aws/rds.rb', line 94

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           => {},
        :event_subscriptions => {},
        :db_engine_versions  => [
          {
            'Engine'                     => "mysql",
            'DBParameterGroupFamily'     => "mysql5.1",
            'DBEngineDescription'        => "MySQL Community Edition",
            'EngineVersion'              => "5.1.57",
            'DBEngineVersionDescription' => "MySQL 5.1.57"
          },
          {
            'Engine'                     => "postgres",
            'DBParameterGroupFamily'     => "postgres9.3",
            'DBEngineDescription'        => "PostgreSQL",
            'EngineVersion'              => "9.3.5",
            'DBEngineVersionDescription' => "PostgreSQL 9.3.5"
          },
        ],
        :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

.reset ⇒ Object 



136
137
138
 
# File 'lib/fog/aws/rds.rb', line 136

def self.reset
  @data = nil
end

Instance Method Details

#add_tags_to_resource(rds_id, tags) ⇒ Object 



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

#authorize_db_security_group_ingress(name, opts = {}) ⇒ Object 



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

#create_db_instance(db_name, options = {}) ⇒ Object 



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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/fog/aws/requests/rds/create_db_instance.rb', line 54

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

  if !!options["MultiAZ"] && !!options["AvailabilityZone"]
    raise Fog::AWS::RDS::InvalidParameterCombination.new('Requesting a specific availability zone is not valid for Multi-AZ instances.')
  end

  ec2 = Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id]

  db_security_group_names = Array(options.delete("DBSecurityGroups"))
  rds_security_groups     = self.data[:security_groups].values
  ec2_security_groups     = ec2[:security_groups].values
  vpc                     = !ec2[:account_attributes].find { |h| "supported-platforms" == h["attributeName"] }["values"].include?("EC2")

  db_security_groups = db_security_group_names.map do |group_name|
    unless rds_security_groups.find { |sg| sg["DBSecurityGroupName"] == group_name }
      raise Fog::AWS::RDS::Error.new("InvalidParameterValue => Invalid security group , groupId= , groupName=#{group_name}")
    end

    {"Status" => "active", "DBSecurityGroupName" => group_name }
  end

  if !vpc && db_security_groups.empty?
    db_security_groups << { "Status" => "active", "DBSecurityGroupName" => "default" }
  end

  vpc_security_groups = Array(options.delete("VpcSecurityGroups")).map do |group_id|
    unless ec2_security_groups.find { |sg| sg["groupId"] == group_id }
      raise Fog::AWS::RDS::Error.new("InvalidParameterValue => Invalid security group , groupId=#{group_id} , groupName=")
    end

    {"Status" => "active", "VpcSecurityGroupId" => group_id }
  end

  data = {
    "AllocatedStorage"                 => options["AllocatedStorage"],
    "AutoMinorVersionUpgrade"          => options["AutoMinorVersionUpgrade"].nil? ? true : options["AutoMinorVersionUpgrade"],
    "AvailabilityZone"                 => options["AvailabilityZone"],
    "BackupRetentionPeriod"            => options["BackupRetentionPeriod"] || 1,
    "CACertificateIdentifier"          => "rds-ca-2015",
    "DBInstanceClass"                  => options["DBInstanceClass"],
    "DBInstanceIdentifier"             => db_name,
    "DBInstanceStatus"                 =>"creating",
    "DBName"                           => options["DBName"],
    "DBParameterGroups"                => [{ "DBParameterGroupName" => "default.mysql5.5", "ParameterApplyStatus" => "in-sync" }],
    "DBSecurityGroups"                 => db_security_groups,
    "DBSubnetGroupName"                => options["DBSubnetGroupName"],
    "Endpoint"                         =>{},
    "Engine"                           => options["Engine"],
    "EngineVersion"                    => options["EngineVersion"] || "5.5.12",
    "InstanceCreateTime"               => nil,
    "Iops"                             => options["Iops"],
    "LicenseModel"                     => "general-public-license",
    "MasterUsername"                   => options["MasterUsername"],
    "MultiAZ"                          => !!options["MultiAZ"],
    "PendingModifiedValues"            => { "MasterUserPassword" => "****" }, # This clears when is available
    "PreferredBackupWindow"            => options["PreferredBackupWindow"] || "08:00-08:30",
    "PreferredMaintenanceWindow"       => options["PreferredMaintenanceWindow"] || "mon:04:30-mon:05:00",
    "PubliclyAccessible"               => !!options["PubliclyAccessible"],
    "ReadReplicaDBInstanceIdentifiers" => [],
    "StorageEncrypted"                 => options["StorageEncrypted"] || false,
    "StorageType"                      => options["StorageType"] || "standard",
    "VpcSecurityGroups"                => vpc_security_groups,
  }

  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

#create_db_instance_read_replica(instance_identifier, source_identifier, options = {}) ⇒ Object 



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
77
78
79
 
# 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'] : source['AutoMinorVersionUpgrade'],
    'AvailabilityZone'                      => options['AvailabilityZone'],
    'BackupRetentionPeriod'                 => options['BackupRetentionPeriod'] || 0,
    'CACertificateIdentifier'               => "rds-ca-2015",
    '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'                         => source['EngineVersion'],
    '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",
    'PubliclyAccessible'                    => !!options["PubliclyAccessible"],
    'ReadReplicaDBInstanceIdentifiers'      => [],
    'ReadReplicaSourceDBInstanceIdentifier' => source_identifier,
    'StorageType'                           => options['StorageType'] || 'standard',
    'StorageEncrypted'                      => false,
    'VpcSecurityGroups'                     => source['VpcSecurityGroups'],
  }
  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

#create_db_parameter_group(group_name, group_family, description) ⇒ Object 



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

#create_db_security_group(name, description = name) ⇒ Object 



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

#create_db_snapshot(identifier, name) ⇒ Object 



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
65
 
# 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

#create_db_subnet_group(name, subnet_ids, description = name) ⇒ Object 



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

#create_event_subscription(options = {}) ⇒ Object 



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

def create_event_subscription(options={})
  response = Excon::Response.new
  name     = options.delete('SubscriptionName')
  arn      = options.delete('SnsTopicArn')

  if self.data[:event_subscriptions][name]
    raise Fog::AWS::RDS::IdentifierTaken.new("SubscriptionAlreadyExist => Subscription already exists")
  end

  subscription = {
    'CustSubscriptionId' => name,
    'EventCategories'    => options['EventCategories'] || [],
    'SourceType'         => options['SourceType'],
    'Enabled'            => options.fetch(:enabled, "true"),
    'Status'             => 'creating',
    'CreationTime'       => Time.now,
    'SnsTopicArn'        => arn,
  }

  self.data[:event_subscriptions][name] = subscription

  response.body = {
    "ResponseMetaData" => {"RequestId" => Fog::AWS::Mock.request_id},
    "CreateEventSubscriptionResult" => { "EventSubscription" => subscription }
  }
  response
end

#data ⇒ Object 



151
152
153
 
# File 'lib/fog/aws/rds.rb', line 151

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

#delete_db_instance(identifier, snapshot_identifier, skip_snapshot = false) ⇒ Object 



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/fog/aws/requests/rds/delete_db_instance.rb', line 30

def delete_db_instance(identifier, snapshot_identifier, skip_snapshot = false)
  response = Excon::Response.new


  server_set = self.data[:servers][identifier] ||
    raise(Fog::AWS::RDS::NotFound.new("DBInstance #{identifier} not found"))

  unless skip_snapshot
    if server_set["ReadReplicaSourceDBInstanceIdentifier"]
      raise Fog::AWS::RDS::Error.new("InvalidParameterCombination => FinalDBSnapshotIdentifier can not be specified when deleting a replica instance")
    else
      create_db_snapshot(identifier, snapshot_identifier)
    end
  end

  self.data[:servers].delete(identifier)

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

#delete_db_parameter_group(group_name) ⇒ Object 



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

#delete_db_security_group(name, description = name) ⇒ Object 



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

#delete_db_snapshot(name) ⇒ Object

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

#delete_db_subnet_group(name) ⇒ Object 



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

#delete_event_subscription(name) ⇒ Object 



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

def delete_event_subscription(name)
  response = Excon::Response.new

  if data = self.data[:event_subscriptions][name]
    data['Status'] = 'deleting'
    self.data[:event_subscriptions][name] = data

    response.status = 200
    response.body = {
      "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
    }
    response
  else
    raise Fog::AWS::RDS::NotFound.new("EventSubscriptionNotFound => #{name} not found")
  end
end

#describe_db_engine_versions(opts = {}) ⇒ Object 



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

def describe_db_engine_versions(opts={})
  response = Excon::Response.new

  response.status = 200
  response.body = {
    "ResponseMetadata"               => { "RequestId"        => Fog::AWS::Mock.request_id },
    "DescribeDBEngineVersionsResult" => { "DBEngineVersions" => self.data[:db_engine_versions] }
  }
  response
end

#describe_db_instances(identifier = nil, opts = {}) ⇒ Object 



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
 
# 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 specified_server = self.data[:servers][identifier]
      server_set << specified_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
         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

#describe_db_log_files(rds_id = nil, opts = {}) ⇒ Object 



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

#describe_db_parameter_groups(name = nil, opts = {}) ⇒ Object 



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

#describe_db_parameters(name, opts = {}) ⇒ Object 



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

#describe_db_reserved_instances(identifier = nil, opts = {}) ⇒ Object 



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

#describe_db_security_groups(opts = {}) ⇒ Object 



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

#describe_db_snapshots(opts = {}) ⇒ Object 



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
 
# 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

#describe_db_subnet_groups(name = nil, opts = {}) ⇒ Object 



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

#describe_event_subscriptions(options = {}) ⇒ Object 



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/describe_event_subscriptions.rb', line 29

def describe_event_subscriptions(options={})
  response = Excon::Response.new
  name     = options['SubscriptionName']

  subscriptions = self.data[:event_subscriptions].values
  subscriptions = subscriptions.select { |s| s['CustSubscriptionId'] == name } if name

  non_active = self.data[:event_subscriptions].values.select { |s| s['Status'] != 'active' }

  non_active.each do |s|
    name = s['CustSubscriptionId']
    if s['Status'] == 'creating'
      s['Status'] = 'active'
      self.data[:event_subscriptions][name] = s
    elsif s['Status'] == 'deleting'
      self.data[:event_subscriptions].delete(name)
    end
  end

  if options['SubscriptionName'] && subscriptions.empty?
    raise Fog::AWS::RDS::NotFound.new("Event Subscription #{options['SubscriptionName']} not found.")
  end

  response.body = {
    "ResponseMetadata" => {"RequestId" => Fog::AWS::Mock.request_id},
    "DescribeEventSubscriptionsResult" => {"EventSubscriptionsList" => subscriptions}
  }
  response
end

#describe_events ⇒ Object 



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

def describe_events
  Fog::Mock.not_implemented
end

#describe_orderable_db_instance_options(engine = nil, opts = {}) ⇒ Object 



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

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



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

#list_tags_for_resource(rds_id) ⇒ Object 



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

#modify_db_instance(db_name, apply_immediately, _options = {}) ⇒ Object 



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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/fog/aws/requests/rds/modify_db_instance.rb', line 49

def modify_db_instance(db_name, apply_immediately, _options={})
  options = _options
  response = Excon::Response.new
  if server = self.data[:servers][db_name]
    if server["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

      db_security_group_names = Array(options.delete("DBSecurityGroups"))

      rds_security_groups = self.data[:security_groups].values

      db_security_groups = db_security_group_names.map do |r, group_name|
        unless rds_security_groups.find { |sg| sg["DBSecurityGroupName"] == group_name }
          raise Fog::AWS::RDS::Error.new("InvalidParameterValue => Invalid security group , groupId= , groupName=#{group_name}")
        end
        r << {"Status" => "active", "DBSecurityGroupName" => group_name }
      end

      ec2_security_groups = Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:security_groups].values

      vpc_security_groups = Array(options.delete("VpcSecurityGroups")).map do |group_id|
        unless ec2_security_groups.find { |sg| sg["groupId"] == group_id }
          raise Fog::AWS::RDS::Error.new("InvalidParameterValue => Invalid security group , groupId=#{group_id} , groupName=")
        end

        {"Status" => "active", "VpcSecurityGroupId" => group_id }
      end

      options.merge!(
        "DBSecurityGroups"  => db_security_groups,
        "VpcSecurityGroups" => vpc_security_groups
      )

      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

#modify_db_parameter_group(group_name, parameters) ⇒ Object 



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

#promote_read_replica(identifier, backup_retention_period = nil, preferred_backup_window = nil) ⇒ Object 



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
 
# 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)
  server = self.data[:servers][identifier]
  server || raise(Fog::AWS::RDS::NotFound.new("DBInstance #{identifier} not found"))

  if server["ReadReplicaSourceDBInstanceIdentifier"].nil?
    raise(Fog::AWS::RDS::Error.new("InvalidDBInstanceState => DB Instance is not a read replica."))
  end

  self.data[:modify_time] = Time.now

  data = {
    'BackupRetentionPeriod' => backup_retention_period || 1,
    'PreferredBackupWindow' => preferred_backup_window || '08:00-08:30',
    'DBInstanceIdentifier'  => identifier,
    'DBInstanceStatus'      => "modifying",
    'PendingModifiedValues' => {
      'ReadReplicaSourceDBInstanceIdentifier' => nil,
    }
  }

  server.merge!(data)

  response = Excon::Response.new
  response.body = {
    "ResponseMetadata"         => { "RequestId"  => Fog::AWS::Mock.request_id },
    "PromoteReadReplicaResult" => { "DBInstance" => server }
  }
  response.status = 200
  response
end

#reboot_db_instance(instance_identifier) ⇒ Object 



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

#remove_tags_from_resource(rds_id, keys) ⇒ Object 



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

#reset_data ⇒ Object 



155
156
157
 
# File 'lib/fog/aws/rds.rb', line 155

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

#restore_db_instance_from_db_snapshot(snapshot_id, db_id, options = {}) ⇒ Object 



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

#restore_db_instance_to_point_in_time(source_db_name, target_db_name, opts = {}) ⇒ Object 



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

#revoke_db_security_group_ingress(name, opts = {}) ⇒ Object 



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

#setup_credentials(options) ⇒ Object 



159
160
161
 
# File 'lib/fog/aws/rds.rb', line 159

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