lib/fog/aws/requests/rds/create_db_instance.rb
module Fog
module AWS
class RDS
class Real
require 'fog/aws/parsers/rds/create_db_instance'
# Create a db instance
#
# @param DBInstanceIdentifier [String] name of the db instance to modify
# @param AllocatedStorage [Integer] Storage space, in GB
# @param AutoMinorVersionUpgrade [Boolean] Indicates that minor version upgrades will be applied automatically to the DB Instance during the maintenance window
# @param AvailabilityZone [String] The availability zone to create the instance in
# @param BackupRetentionPeriod [Integer] 0-8 The number of days to retain automated backups.
# @param DBInstanceClass [String] The new compute and memory capacity of the DB Instance
# @param DBName [String] The name of the database to create when the DB Instance is created
# @param DBParameterGroupName [String] The name of the DB Parameter Group to apply to this DB Instance
# @param DBSecurityGroups [Array] A list of DB Security Groups to authorize on this DB Instance
# @param Engine [String] The name of the database engine to be used for this instance.
# @param EngineVersion [String] The version number of the database engine to use.
# @param Iops [Integer] IOPS rate
# @param MasterUsername [String] The db master user
# @param MasterUserPassword [String] The new password for the DB Instance master user
# @param MultiAZ [Boolean] Specifies if the DB Instance is a Multi-AZ deployment
# @param Port [Integer] The port number on which the database accepts connections.
# @param PreferredBackupWindow [String] The daily time range during which automated backups are created if automated backups are enabled
# @param PreferredMaintenanceWindow [String] The weekly time range (in UTC) during which system maintenance can occur, which may result in an outage
# @param DBSubnetGroupName [String] The name, if any, of the VPC subnet for this RDS instance
# @param PubliclyAccessible [Boolean] Whether an RDS instance inside of the VPC subnet should have a public-facing endpoint
# @param VpcSecurityGroups [Array] A list of VPC Security Groups to authorize on this DB instance
# @param StorageType [string] Specifies storage type to be associated with the DB Instance. Valid values: standard | gp2 | io1
#
# @return [Excon::Response]:
# * body [Hash]:
#
# @see http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html
def create_db_instance(db_name, options={})
if security_groups = options.delete('DBSecurityGroups')
options.merge!(Fog::AWS.indexed_param('DBSecurityGroups.member.%d', [*security_groups]))
end
if vpc_security_groups = options.delete('VpcSecurityGroups')
options.merge!(Fog::AWS.indexed_param('VpcSecurityGroupIds.member.%d', [*vpc_security_groups]))
end
request({
'Action' => 'CreateDBInstance',
'DBInstanceIdentifier' => db_name,
:parser => Fog::Parsers::AWS::RDS::CreateDBInstance.new,
}.merge(options))
end
end
class Mock
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
end
end
end
end