fog-aws 0.8.1 → 0.9.0

data/lib/fog/aws/requests/compute/describe_availability_zones.rb

@@ -22,7 +22,7 @@ module Fog
         def describe_availability_zones(filters = {})
           unless filters.is_a?(Hash)
             Fog::Logger.deprecation("describe_availability_zones with #{filters.class} param is deprecated, use describe_availability_zones('zone-name' => []) instead [light_black](#{caller.first})[/]")
-            filters = {'public-ip' => [*filters]}
+            filters = {'zone-name' => [*filters]}
           end
           params = Fog::AWS.indexed_filters(filters)
           request({
@@ -37,7 +37,7 @@ module Fog
         def describe_availability_zones(filters = {})
           unless filters.is_a?(Hash)
             Fog::Logger.deprecation("describe_availability_zones with #{filters.class} param is deprecated, use describe_availability_zones('zone-name' => []) instead [light_black](#{caller.first})[/]")
-            filters = {'public-ip' => [*filters]}
+            filters = {'zone-name' => [*filters]}
           end
 
           response = Excon::Response.new
@@ -69,6 +69,9 @@ module Fog
             {"messageSet" => [], "regionName" => "ap-northeast-1", "zoneName" => "ap-northeast-1a", "zoneState" => "available"},
             {"messageSet" => [], "regionName" => "ap-northeast-1", "zoneName" => "ap-northeast-1b", "zoneState" => "available"},
 
+            {"messageSet" => [], "regionName" => "ap-northeast-2", "zoneName" => "ap-northeast-2a", "zoneState" => "available"},
+            {"messageSet" => [], "regionName" => "ap-northeast-2", "zoneName" => "ap-northeast-2b", "zoneState" => "available"},
+
             {"messageSet" => [], "regionName" => "ap-southeast-1", "zoneName" => "ap-southeast-1a", "zoneState" => "available"},
             {"messageSet" => [], "regionName" => "ap-southeast-1", "zoneName" => "ap-southeast-1b", "zoneState" => "available"},
 

data/lib/fog/aws/requests/rds/create_db_cluster.rb

@@ -0,0 +1,98 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/create_db_cluster'
+
+        # Create a db cluster
+        #
+        # @see http://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html
+        #
+        # ==== Parameters ====
+        # * AvailabilityZones<~Array> - A list of EC2 Availability Zones that instances in the DB cluster can be created in
+        # * BackupRetentionPeriod<~String> - The number of days for which automated backups are retained
+        # * CharacterSetName<~String> - A value that indicates that the DB cluster should be associated with the specified CharacterSet
+        # * DatabaseName<~String> - The name for your database of up to 8 alpha-numeric characters. If you do not provide a name, Amazon RDS will not create a database in the DB cluster you are creating
+        # * DBClusterIdentifier<~String> - The DB cluster identifier. This parameter is stored as a lowercase string
+        # * DBClusterParameterGroupName<~String> - The name of the DB cluster parameter group to associate with this DB cluster
+        # * DBSubnetGroupName<~String> - A DB subnet group to associate with this DB cluster
+        # * Engine<~String> - The name of the database engine to be used for this DB cluster
+        # * EngineVersion<~String> - The version number of the database engine to use
+        # * KmsKeyId<~String> - The KMS key identifier for an encrypted DB cluster
+        # * MasterUsername<~String> - The name of the master user for the client DB cluster
+        # * MasterUserPassword<~String> - The password for the master database user
+        # * OptionGroupName<~String> - A value that indicates that the DB cluster should be associated with the specified option group
+        # * Port<~Integer> - The port number on which the instances in the DB cluster accept connections
+        # * PreferredBackupWindow<~String> - The daily time range during which automated backups are created if automated backups are enabled using the BackupRetentionPeriod parameter
+        # * PreferredMaintenanceWindow<~String> - The weekly time range during which system maintenance can occur, in Universal Coordinated Time (UTC)
+        # * StorageEncrypted<~Boolean> - Specifies whether the DB cluster is encrypted
+        # * Tags<~Array> - A list of tags
+        # * VpcSecurityGroups<~Array> - A list of EC2 VPC security groups to associate with this DB cluster
+        #
+        # ==== Returns ====
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+
+        def create_db_cluster(cluster_name, options={})
+          if security_groups = options.delete('VpcSecurityGroups')
+            options.merge!(Fog::AWS.indexed_param('VpcSecurityGroupIds.member.%d', [*security_groups]))
+          end
+
+          request({
+            'Action'              => 'CreateDBCluster',
+            'DBClusterIdentifier' => cluster_name,
+            :parser               => Fog::Parsers::AWS::RDS::CreateDBCluster.new,
+          }.merge(options))
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/rds/create_db_cluster_snapshot.rb

@@ -0,0 +1,68 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/create_db_cluster_snapshot'
+
+        # create a snapshot of a db cluster
+        # http://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBClusterSnapshot.html
+        #
+        # ==== Parameters ====
+        # * DBClusterIdentifier<~String> - The identifier of the DB cluster to create a snapshot for
+        # * DBClusterSnapshotIdentifier<~String> - The identifier of the DB cluster snapshot
+        # * Tags<~Array> - The tags to be assigned to the DB cluster snapshot
+        #
+        # ==== Returns ====
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+
+        def create_db_cluster_snapshot(identifier, name)
+          request(
+            'Action'                      => 'CreateDBClusterSnapshot',
+            'DBClusterIdentifier'         => identifier,
+            'DBClusterSnapshotIdentifier' => name,
+            :parser                       => Fog::Parsers::AWS::RDS::CreateDBClusterSnapshot.new
+          )
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/rds/create_db_instance.rb

@@ -65,7 +65,8 @@ module Fog
           end
 
           # These are the required parameters according to the API
-          required_params = %w{AllocatedStorage DBInstanceClass Engine MasterUserPassword MasterUsername }
+          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
@@ -84,6 +85,16 @@ module Fog
 
           ec2 = Fog::Compute::AWS::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
@@ -109,17 +120,44 @@ module Fog
             {"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"                => [{ "DBParameterGroupName" => "default.mysql5.5", "ParameterApplyStatus" => "in-sync" }],
+            "DBParameterGroups"                => db_parameter_groups,
             "DBSecurityGroups"                 => db_security_groups,
             "DBSubnetGroupName"                => options["DBSubnetGroupName"],
             "Endpoint"                         =>{},
@@ -128,14 +166,14 @@ module Fog
             "InstanceCreateTime"               => nil,
             "Iops"                             => options["Iops"],
             "LicenseModel"                     => "general-public-license",
-            "MasterUsername"                   => options["MasterUsername"],
+            "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"                 => options["StorageEncrypted"] || false,
+            "StorageEncrypted"                 => cluster_id ? cluster["StorageEncrypted"] : (options["StorageEncrypted"] || false),
             "StorageType"                      => options["StorageType"] || "standard",
             "VpcSecurityGroups"                => vpc_security_groups,
           }

data/lib/fog/aws/requests/rds/create_db_snapshot.rb

@@ -45,7 +45,7 @@ module Fog
             'InstanceCreateTime'   => Time.now
           }
           # Copy attributes from server
-          %w(Engine EngineVersion AvailabilityZone AllocatedStorage Iops MasterUsername InstanceCreateTime).each do |key|
+          %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']

data/lib/fog/aws/requests/rds/delete_db_cluster.rb

@@ -0,0 +1,55 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/delete_db_cluster'
+
+        # delete a database cluster
+        #
+        # @see http://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteDBCluster.html
+        #
+        # ==== Parameters ====
+        # * DBClusterIdentifier <~String> - The DB cluster identifier for the DB cluster to be deleted
+        # * FinalDBSnapshotIdentifier <~String> - The DB cluster snapshot identifier of the new DB cluster snapshot created when SkipFinalSnapshot is set to false
+        # * SkipFinalSnapshot <~Boolean> - Determines whether a final DB cluster snapshot is created before the DB cluster is deleted
+        #
+        # ==== Returns ====
+        # * response<~Excon::Response>
+        #   * body<~Hash>
+
+        def delete_db_cluster(identifier, snapshot_identifier, skip_snapshot = false)
+          params = {}
+          params["FinalDBSnapshotIdentifier"] = snapshot_identifier if snapshot_identifier
+          request({
+            'Action'              => 'DeleteDBCluster',
+            'DBClusterIdentifier' => identifier,
+            'SkipFinalSnapshot'   => skip_snapshot,
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/rds/delete_db_cluster_snapshot.rb

@@ -0,0 +1,43 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/delete_db_cluster_snapshot'
+
+        # delete a db cluster snapshot
+        # http://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteDBClusterSnapshot.html
+        #
+        # ==== Parameters ====
+        # * DBClusterSnapshotIdentifier<~String> - The identifier of the DB cluster snapshot to delete
+        #
+        # ==== Returns ====
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+
+        def delete_db_cluster_snapshot(name)
+          request(
+            'Action'                      => 'DeleteDBClusterSnapshot',
+            'DBClusterSnapshotIdentifier' => name,
+            :parser                       => Fog::Parsers::AWS::RDS::DeleteDBClusterSnapshot.new
+          )
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/rds/delete_db_instance.rb

@@ -37,11 +37,20 @@ module Fog
           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"]
+              raise Fog::AWS::RDS::Error.new("InvalidParameterCombination => FinalDBSnapshotIdentifier can not be specified when deleting a cluster instance")
             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

data/lib/fog/aws/requests/rds/delete_db_snapshot.rb

@@ -26,8 +26,9 @@ module Fog
           # 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("DBSnapshtoNotFound => #{name} not found") unless snapshot_data
+          raise Fog::AWS::RDS::NotFound.new("DBSnapshotNotFound => #{name} not found") unless snapshot_data
 
           response.status = 200
           response.body = {

data/lib/fog/aws/requests/rds/describe_db_cluster_snapshots.rb

@@ -0,0 +1,66 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/describe_db_cluster_snapshots'
+
+        # Describe all or specified db cluster snapshots
+        # http://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBClusterSnapshots.html
+        #
+        # ==== Parameters ====
+        # * DBClusterIdentifier<~String> - A DB cluster identifier to retrieve the list of DB cluster snapshots for
+        # * DBClusterSnapshotIdentifier<~String> - A specific DB cluster snapshot identifier to describe
+        # * SnapshotType<~String> - The type of DB cluster snapshots that will be returned. Values can be automated or manual
+        #
+        # ==== Returns ====
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+
+        def describe_db_cluster_snapshots(opts={})
+          params                                = {}
+          params['SnapshotType']                = opts[:type]        if opts[:type]
+          params['DBClusterIdentifier']         = opts[:identifier]  if opts[:identifier]
+          params['DBClusterSnapshotIdentifier'] = opts[:snapshot_id] if opts[:snapshot_id]
+          params['Marker']                      = opts[:marker]      if opts[:marker]
+          params['MaxRecords']                  = opts[:max_records] if opts[:max_records]
+          request({
+            'Action' => 'DescribeDBClusterSnapshots',
+            :parser  => Fog::Parsers::AWS::RDS::DescribeDBClusterSnapshots.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end