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