class Fog::AWS::RDS::Mock

Attributes

aws_access_key_id[RW]
region[RW]

Public Class Methods

data() click to toggle source
# File lib/fog/aws/rds.rb, line 109
def self.data
  @data ||= Hash.new do |hash, region|
    hash[region] = Hash.new do |region_hash, key|
      region_hash[key] = {
        :clusters            => {},
        :cluster_snapshots   => {},
        :servers             => {},
        :security_groups     => {},
        :subnet_groups       => {},
        :snapshots           => {},
        :event_subscriptions => {},
        :default_parameters  => [
          {
            "DataType"      => "integer",
            "Source"        => "engine-default",
            "Description"   => "Intended for use with master-to-master replication, and can be used to control the operation of AUTO_INCREMENT columns",
            "ApplyType"     => "dynamic",
            "AllowedValues" => "1-65535",
            "ParameterName" => "auto_increment_increment"
          }
        ],
        :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
new(options={}) click to toggle source
# File lib/fog/aws/rds.rb, line 169
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
reset() click to toggle source
# File lib/fog/aws/rds.rb, line 163
def self.reset
  @data = nil
end

Public Instance Methods

add_tags_to_resource(rds_id, tags) click to toggle source
# File lib/fog/aws/requests/rds/add_tags_to_resource.rb, line 28
def add_tags_to_resource(rds_id, tags)
  response = Excon::Response.new
  if server = data[:servers][rds_id]
    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, "DBInstance #{rds_id} not found"
  end
end
authorize_db_security_group_ingress(name, opts = {}) click to toggle source
# 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?('EC2SecurityGroupId')) && opts.key?('EC2SecurityGroupOwnerId'))
    raise ArgumentError, 'Must specify CIDRIP, or one of EC2SecurityGroupName or EC2SecurityGroupId, and EC2SecurityGroupOwnerId'
  end

  if ec2_security_group_id = opts.delete("EC2SecurityGroupId")
    ec2_security_group = (Fog::AWS::Compute::Mock.data[self.region][self.aws_access_key_id][:security_groups] || {}).values.detect { |sg| sg['groupId'] == ec2_security_group_id }
    opts['EC2SecurityGroupName'] = ec2_security_group['groupName']
  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'] || h['EC2SecurityGroupId'] == opts['EC2SecurityGroupId']}
        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
copy_db_snapshot(source_db_snapshot_identifier, target_db_snapshot_identifier, copy_tags = false) click to toggle source

Usage

Fog::AWS.copy_db_snapshot(“snap-original-id”, “snap-backup-id”, true)

# File lib/fog/aws/requests/rds/copy_db_snapshot.rb, line 37
def copy_db_snapshot(source_db_snapshot_identifier, target_db_snapshot_identifier, copy_tags = false)
  response = Excon::Response.new
  response.status = 200
  snapshot_id =  Fog::AWS::Mock.snapshot_id
  data = self.data[:snapshots]["#{source_db_snapshot_identifier}"]
  data['DBSnapshotIdentifier'] = snapshot_id
  self.data[:snapshots][snapshot_id] = data
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id,
    'CopyDBSnapshotResult' => {'DBSnapshot' => data.dup}
  }
  response
end
create_db_cluster(cluster_name, options={}) click to toggle source
# File lib/fog/aws/requests/rds/create_db_cluster.rb, line 50
def create_db_cluster(cluster_name, options={})
  response = Excon::Response.new
  if self.data[:clusters][cluster_name]
    raise Fog::AWS::RDS::IdentifierTaken.new("DBClusterAlreadyExists")
  end

  required_params = %w(Engine MasterUsername MasterUserPassword)
  required_params.each do |key|
    unless options.key?(key) && options[key] && !options[key].to_s.empty?
      raise Fog::AWS::RDS::NotFound.new("The request must contain the parameter #{key}")
    end
  end

  vpc_security_groups = Array(options.delete("VpcSecurityGroups")).map do |group_id|
    {"VpcSecurityGroupId" => group_id }
  end

  data = {
    'AllocatedStorage'           => "1",
    'BackupRetentionPeriod'      => (options["BackupRetentionPeriod"] || 35).to_s,
    'ClusterCreateTime'          => Time.now,
    'DBClusterIdentifier'        => cluster_name,
    'DBClusterMembers'           => [],
    'DBClusterParameterGroup'    => options['DBClusterParameterGroup'] || "default.aurora5.6",
    'DBSubnetGroup'              => options["DBSubnetGroup"] || "default",
    'Endpoint'                   => "#{cluster_name}.cluster-#{Fog::Mock.random_hex(8)}.#{@region}.rds.amazonaws.com",
    'Engine'                     => options["Engine"] || "aurora5.6",
    'EngineVersion'              => options["EngineVersion"] || "5.6.10a",
    'MasterUsername'             => options["MasterUsername"],
    'Port'                       => options["Port"] || "3306",
    'PreferredBackupWindow'      => options["PreferredBackupWindow"] || "04:45-05:15",
    'PreferredMaintenanceWindow' => options["PreferredMaintenanceWindow"] || "sat:05:56-sat:06:26",
    'Status'                     => "available",
    'StorageEncrypted'           => options["StorageEncrypted"] || false,
    'VpcSecurityGroups'          => vpc_security_groups,
  }

  self.data[:clusters][cluster_name] = data
  response.body = {
    "ResponseMetadata" =>      { "RequestId" => Fog::AWS::Mock.request_id },
    "CreateDBClusterResult" => { "DBCluster" => data.dup.reject { |k,v| k == 'ClusterCreateTime' } }
  }
  response.status = 200
  response
end
create_db_cluster_snapshot(identifier, name) click to toggle source
# File lib/fog/aws/requests/rds/create_db_cluster_snapshot.rb, line 30
def create_db_cluster_snapshot(identifier, name)
  response = Excon::Response.new

  if data[:cluster_snapshots][name]
    raise Fog::AWS::RDS::IdentifierTaken.new
  end

  cluster = self.data[:clusters][identifier]

  raise Fog::AWS::RDS::NotFound.new("DBCluster #{identifier} not found") unless cluster

  data = {
    'AllocatedStorage'            => cluster['AllocatedStorage'].to_i,
    'ClusterCreateTime'           => cluster['ClusterCreateTime'],
    'DBClusterIdentifier'         => identifier,
    'DBClusterSnapshotIdentifier' => name,
    'Engine'                      => cluster['Engine'],
    'EngineVersion'               => cluster['EngineVersion'],
    'LicenseModel'                => cluster['Engine'],
    'MasterUsername'              => cluster['MasterUsername'],
    'SnapshotCreateTime'          => Time.now,
    'SnapshotType'                => 'manual',
    'StorageEncrypted'            => cluster["StorageEncrypted"],
    'Status'                      => 'creating',
  }

  self.data[:cluster_snapshots][name] = data

  response.body = {
    "ResponseMetadata"              => { "RequestId" => Fog::AWS::Mock.request_id },
    "CreateDBClusterSnapshotResult" => { "DBClusterSnapshot" => data.dup },
  }
  self.data[:cluster_snapshots][name]['SnapshotCreateTime'] = Time.now
  response
end
create_db_instance(db_name, options={}) click to toggle source
# 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(DBInstanceClass Engine)
  required_params += %w{AllocatedStorage DBInstanceClass Engine MasterUserPassword MasterUsername } unless options["DBClusterIdentifier"]
  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::AWS::Compute::Mock.data[@region][@aws_access_key_id]

  db_parameter_groups     = if pg_name = options.delete("DBParameterGroupName")
                              group = self.data[:parameter_groups][pg_name]
                              if group
                                [{"DBParameterGroupName" => pg_name, "ParameterApplyStatus" => "in-sync" }]
                              else
                                raise Fog::AWS::RDS::NotFound.new("Parameter group does not exist")
                              end
                            else
                              [{ "DBParameterGroupName" => "default.mysql5.5", "ParameterApplyStatus" => "in-sync" }]
                            end
  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

  if options["Engine"] == "aurora" && ! options["DBClusterIdentifier"]
    raise Fog::AWS::RDS::Error.new("InvalidParameterStateValue => Standalone instances for this engine are not supported")
  end

  if cluster_id = options["DBClusterIdentifier"]
    if vpc_security_groups.any?
      raise Fog::AWS::RDS::Error.new("InvalidParameterCombination => The requested DB Instance will be a member of a DB Cluster and its vpc security group should not be set directly.")
    end

    if options["MultiAZ"]
      raise Fog::AWS::RDS::Error.new("InvalidParameterCombination => VPC Multi-AZ DB Instances are not available for engine: aurora")
    end

    %w(AllocatedStorage BackupRetentionPeriod MasterUsername MasterUserPassword).each do |forbidden|
      raise Fog::AWS::RDS::Error.new("InvalidParameterCombination => The requested DB Instance will be a member of a DB Cluster and its #{forbidden} should not be set directly.") if options[forbidden]
    end

    options["StorageType"] = "aurora"

    cluster = self.data[:clusters][cluster_id]

    member = {"DBInstanceIdentifier" => db_name, "master" => cluster['DBClusterMembers'].empty?}
    cluster['DBClusterMembers'] << member
    self.data[:clusters][cluster_id] = cluster
  end

  data = {
    "AllocatedStorage"                 => options["AllocatedStorage"],
    "AutoMinorVersionUpgrade"          => options["AutoMinorVersionUpgrade"].nil? ? true : options["AutoMinorVersionUpgrade"],
    "AvailabilityZone"                 => options["AvailabilityZone"],
    "BackupRetentionPeriod"            => options["BackupRetentionPeriod"] || 1,
    "CACertificateIdentifier"          => "rds-ca-2015",
    "DBClusterIdentifier"              => options["DBClusterIdentifier"],
    "DBInstanceClass"                  => options["DBInstanceClass"],
    "DBInstanceIdentifier"             => db_name,
    "DBInstanceStatus"                 =>"creating",
    "DBName"                           => options["DBName"],
    "DBParameterGroups"                => db_parameter_groups,
    "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"                   => cluster_id ? cluster["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"                 => cluster_id ? cluster["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={}) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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::IdentifierTaken.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 StorageType).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) click to toggle source
# 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::AWS::Compute.new(:aws_access_key_id => 'mock key', :aws_secret_access_key => 'mock secret')
  compute_data = Fog::AWS::Compute::Mock.data[self.region][self.aws_access_key_id]

  subnets = subnet_ids.map do |snid|
    subnet = compute_data[:subnets].detect { |s| s['subnetId'] == snid }
    raise Fog::AWS::RDS::NotFound.new("InvalidSubnet => The subnet '#{snid}' was not found") if subnet.nil?
    subnet
  end
  vpc_id = subnets.first['vpcId']

  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={}) click to toggle source
# 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() click to toggle source
# File lib/fog/aws/rds.rb, line 178
def data
  self.class.data[@region][@aws_access_key_id]
end
delete_db_cluster(identifier, snapshot_identifier, skip_snapshot = false) click to toggle source
# File lib/fog/aws/requests/rds/delete_db_cluster.rb, line 32
def delete_db_cluster(identifier, snapshot_identifier, skip_snapshot = false)
  response = Excon::Response.new

  cluster = self.data[:clusters][identifier] || raise(Fog::AWS::RDS::NotFound.new("DBCluster #{identifier} not found"))

  raise Fog::AWS::RDS::Error.new("InvalidDBClusterStateFault => Cluster cannot be deleted, it still contains DB instances in non-deleting state.") if cluster["DBClusterMembers"].any?

  unless skip_snapshot
    create_db_cluster_snapshot(identifier, snapshot_identifier)
  end

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

  response.status = 200
  response.body   = {
    "ResponseMetadata"      => { "RequestId" => Fog::AWS::Mock.request_id },
    "DeleteDBClusterResult" => { "DBCluster" => cluster}
  }
  response
end
delete_db_cluster_snapshot(name) click to toggle source
# File lib/fog/aws/requests/rds/delete_db_cluster_snapshot.rb, line 27
def delete_db_cluster_snapshot(name)
  response = Excon::Response.new
  snapshot = self.data[:cluster_snapshots].delete(name)

  raise Fog::AWS::RDS::NotFound.new("DBClusterSnapshotNotFound => #{name} not found") unless snapshot

  response.status = 200
  response.body = {
    "ResponseMetadata"              => {"RequestId"         => Fog::AWS::Mock.request_id},
    "DeleteDBClusterSnapshotResult" => {"DBClusterSnapshot" => snapshot}
  }
  response
end
delete_db_instance(identifier, snapshot_identifier, skip_snapshot = false) click to toggle source
# 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")
    elsif server_set["DBClusterIdentifier"] && snapshot_identifier # for cluster instances, you must pass in skip_snapshot = false, but not specify a snapshot identifier
      raise Fog::AWS::RDS::Error.new("InvalidParameterCombination => FinalDBSnapshotIdentifier can not be specified when deleting a cluster instance")
    elsif server_set["DBClusterIdentifier"] && !snapshot_identifier && !skip_snapshot
      #no-op
    else
      create_db_snapshot(identifier, snapshot_identifier)
    end
  end

  cluster = self.data[:clusters].values.detect { |c| c["DBClusterMembers"].any? { |m| m["DBInstanceIdentifier"] == identifier } }

  if cluster
    cluster["DBClusterMembers"].delete_if { |v| v["DBInstanceIdentifier"] == identifier }
    self.data[:clusters][cluster["DBClusterIdentifier"]] = cluster
  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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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)
  snapshot_data = self.data[:cluster_snapshots].delete(name) unless snapshot_data

  raise Fog::AWS::RDS::NotFound.new("DBSnapshotNotFound => #{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) click to toggle source
# 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

  self.data[:subnet_groups].delete(name)

  response.body = {
    'ResponseMetadata'=>{ 'RequestId'=> Fog::AWS::Mock.request_id },
    'return' => true,
  }
  response
end
delete_event_subscription(name) click to toggle source
# 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_cluster_snapshots(opts={}) click to toggle source
# File lib/fog/aws/requests/rds/describe_db_cluster_snapshots.rb, line 34
def describe_db_cluster_snapshots(opts={})
  response = Excon::Response.new
  snapshots = self.data[:cluster_snapshots].values

  if opts[:identifier]
    snapshots = snapshots.select { |snapshot| snapshot['DBClusterIdentifier'] == opts[:identifier] }
  end

  if opts[:snapshot_id]
    snapshots = snapshots.select { |snapshot| snapshot['DBClusterSnapshotIdentifier'] == opts[:snapshot_id] }
    raise Fog::AWS::RDS::NotFound.new("DBClusterSnapshot #{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 },
    'DescribeDBClusterSnapshotsResult' => { 'DBClusterSnapshots' => snapshots }
  }
  response
end
describe_db_clusters(identifier=nil, opts={}) click to toggle source
# File lib/fog/aws/requests/rds/describe_db_clusters.rb, line 30
def describe_db_clusters(identifier=nil, opts={})
  response    = Excon::Response.new
  cluster_set = []

  if identifier
    if cluster = self.data[:clusters][identifier]
      cluster_set << cluster
    else
      raise Fog::AWS::RDS::NotFound.new("DBCluster #{identifier} not found")
    end
  else
    cluster_set = self.data[:clusters].values
  end

  response.status = 200
  response.body = {
    "ResponseMetadata"         => { "RequestId"  => Fog::AWS::Mock.request_id },
    "DescribeDBClustersResult" => { "DBClusters" => cluster_set }
  }
  response
end
describe_db_engine_versions(opts={}) click to toggle source
# 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={}) click to toggle source
# 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
          if new_id = server["PendingModifiedValues"] && server["PendingModifiedValues"]["DBInstanceIdentifier"]
            self.data[:servers][new_id] = self.data[:servers].delete(server["DBInstanceIdentifier"])
          end

          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={}) click to toggle source
# 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={}) click to toggle source
# 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={}) click to toggle source
# File lib/fog/aws/requests/rds/describe_db_parameters.rb, line 36
def describe_db_parameters(name, opts={})
  group = self.data[:parameter_groups][name]

  unless group
    raise Fog::AWS::RDS::NotFound.new("parameter group does not exist")
  end

  parameters = group[:parameters]

  response = Excon::Response.new
  response.body = {
    "ResponseMetadata"           => { "RequestId"  => Fog::AWS::Mock.request_id },
    "DescribeDBParametersResult" => { "Parameters" => parameters }
  }
  response.status = 200
  response
end
describe_db_reserved_instances(identifier=nil, opts={}) click to toggle source
# 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={}) click to toggle source
# 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={}) click to toggle source
# 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 = {}) click to toggle source
# 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_engine_default_parameters(family, opts={}) click to toggle source
# File lib/fog/aws/requests/rds/describe_engine_default_parameters.rb, line 27
def describe_engine_default_parameters(family, opts={})
  response = Excon::Response.new

  response.status = 200
  response.body   = {
    "ResponseMetadata"                      => { "RequestId"  => Fog::AWS::Mock.request_id },
    "DescribeEngineDefaultParametersResult" => { "Parameters" => self.data[:default_parameters]}
  }
  response
end
describe_event_subscriptions(options={}) click to toggle source
# 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() click to toggle source
# 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={}) click to toggle source
# 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'},
                              {'Name' => 'us-east-1c'},
                              {'Name' => 'us-east-1d'},
                              {'Name' => 'us-east-1e'}],
                           'DBInstanceClass' => size,
                           'SupportsStorageEncryption' => true,
                           'SupportsPerformanceInsights' => false,
                           'StorageType' => 'gp2',
                           'SupportsIops' => false,
                           'SupportsIAMDatabaseAuthentication' => false,
                           'SupportsEnhancedMonitoring' => true,
                           '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={}) click to toggle source
# 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) click to toggle source
# File lib/fog/aws/requests/rds/list_tags_for_resource.rb, line 27
def list_tags_for_resource(rds_id)
  response = Excon::Response.new
  if server = data[:servers][rds_id]
    response.status = 200
    response.body = {
      'ListTagsForResourceResult' =>
        { 'TagList' => data[:tags][rds_id] }
    }
    response
  else
    raise Fog::AWS::RDS::NotFound, "DBInstance #{rds_id} not found"
  end
end
modify_db_instance(db_name, apply_immediately, _options={}) click to toggle source
# File lib/fog/aws/requests/rds/modify_db_instance.rb, line 49
def modify_db_instance(db_name, apply_immediately, _options={})
  options = _options.dup
  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
      if options["NewDBInstanceIdentifier"]
        options["DBInstanceIdentifier"] = options.delete("NewDBInstanceIdentifier")
        options["Endpoint"]             = {"Port" => server["Endpoint"]["Port"], "Address"=> Fog::AWS::Mock.rds_address(options["DBInstanceIdentifier"],region)}
      end

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

      db_security_group_names = Array(options.delete("DBSecurityGroups"))
      db_security_groups = db_security_group_names.inject([]) 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

      vpc_security_groups = Array(options.delete("VpcSecurityGroups")).inject([]) do |r, 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

        r << {"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) click to toggle source
# File lib/fog/aws/requests/rds/modify_db_parameter_group.rb, line 44
def modify_db_parameter_group(group_name, parameters)
  group = self.data[:parameter_groups][group_name]

  unless group
    raise Fog::AWS::RDS::NotFound.new("Parameter group not found")
  end

  parameters.each do |p|
    p.merge!(
      "Source"        => "user",
      "IsModifiable"  => true,
      "Description"   => "some string",
      "DataType"      => "string",
      "AllowedValues" => p["ParameterValue"],
      "ApplyType"     => "dynamic"
    )
  end

  group[:parameters] = parameters

  self.data[:parameter_groups][group_name] = group

  response = Excon::Response.new
  response.body = {
    "ResponseMetadata"             => {"RequestId"            => Fog::AWS::Mock.request_id},
    "ModifyDBParameterGroupResult" => {"DBParameterGroupName" => group_name}
  }
  response.status = 200
  response
end
modify_db_snapshot_attribute(db_snapshot_identifier, attributes) click to toggle source

Usage

Fog::AWS.modify_db_snapshot_attribute(“snap-identifier”, {“Add.MemberId”=>“389480430104”})

# File lib/fog/aws/requests/rds/modify_db_snapshot_attribute.rb, line 37
def modify_db_snapshot_attribute(db_snapshot_identifier, attributes)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    'requestId' => Fog::AWS::Mock.request_id
  }.merge!(data)
  response
end
promote_read_replica(identifier, backup_retention_period = nil, preferred_backup_window = nil) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# File lib/fog/aws/requests/rds/remove_tags_from_resource.rb, line 25
def remove_tags_from_resource(rds_id, keys)
  response = Excon::Response.new
  if server = data[:servers][rds_id]
    keys.each { |key| 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, "DBInstance #{rds_id} not found"
  end
end
reset_data() click to toggle source
# File lib/fog/aws/rds.rb, line 182
def reset_data
  self.class.data[@region].delete(@aws_access_key_id)
end
restore_db_instance_from_db_snapshot(snapshot_id, db_name, options={}) click to toggle source
# 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_name, options={})

  if self.data[:servers] and self.data[:servers][db_name]
    raise Fog::AWS::RDS::IdentifierTaken.new("DBInstanceAlreadyExists #{response.body.to_s}")
  end

  unless self.data[:snapshots] and snapshot = self.data[:snapshots][snapshot_id]
    raise Fog::AWS::RDS::NotFound.new("DBSnapshotNotFound #{response.body.to_s}")
  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

  option_group_membership =
    if option_group_name = options['OptionGroupName']
      [{ 'OptionGroupMembership' =>
        [{ 'OptionGroupName' => option_group_name, 'Status' => "pending-apply"}] }]
    else
      [{ 'OptionGroupMembership' =>
        [{ 'OptionGroupName' => 'default: mysql-5.6', 'Status' => "pending-apply"}] }]
    end

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

  self.data[:servers][db_name] = data
  response = Excon::Response.new
  response.body =
    { "ResponseMetadata" => { "RequestId" => Fog::AWS::Mock.request_id },
      "RestoreDBInstanceFromDBSnapshotResult" => { "DBInstance" => data }
  }
  response.status = 200
  self.data[:servers][db_name]["InstanceCreateTime"] = Time.now
  response
end
restore_db_instance_to_point_in_time(source_db_name, target_db_name, opts={}) click to toggle source
# 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 = {}) click to toggle source
# 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?('EC2SecurityGroupId')) && opts.key?('EC2SecurityGroupOwnerId'))
    raise ArgumentError, 'Must specify CIDRIP, or one of EC2SecurityGroupName or EC2SecurityGroupId, and EC2SecurityGroupOwnerId'
  end

  if ec2_security_group_id = opts.delete("EC2SecurityGroupId")
    ec2_security_group = (Fog::AWS::Compute::Mock.data[self.region][self.aws_access_key_id][:security_groups] || {}).values.detect { |sg| sg['groupId'] == ec2_security_group_id }
    opts['EC2SecurityGroupName'] = ec2_security_group['groupName']
  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
# File lib/fog/aws/rds.rb, line 186
def setup_credentials(options)
  @aws_access_key_id = options[:aws_access_key_id]
end