fog-aws 0.8.1 → 0.9.0

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

@@ -0,0 +1,54 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/describe_db_clusters'
+
+        # Describe all or specified db clusters
+        # http://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBClusters.html
+        #
+        # ==== Parameters ====
+        # * DBClusterIdentifier<~String> - The user-supplied DB cluster identifier
+        #
+        # ==== Returns ====
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_db_clusters(identifier=nil, opts={})
+          params = {}
+          params['DBClusterIdentifier'] = identifier         if identifier
+          params['Marker']              = opts[:marker]      if opts[:marker]
+          params['MaxRecords']          = opts[:max_records] if opts[:max_records]
+
+          request({
+            'Action' => 'DescribeDBClusters',
+            :parser  => Fog::Parsers::AWS::RDS::DescribeDBClusters.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end

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

@@ -64,6 +64,10 @@ module Fog
               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'

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

@@ -34,7 +34,21 @@ module Fog
 
       class Mock
         def describe_db_parameters(name, opts={})
-          Fog::Mock.not_implemented
+          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
       end
     end

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

@@ -0,0 +1,40 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/describe_engine_default_parameters'
+
+        # Returns the default engine and system parameter information for the specified database engine
+        # http://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeEngineDefaultParameters.html
+        #
+        # ==== Parameters ====
+        # * DBParameterGroupFamily<~String> - The name of the DB parameter group family
+        #
+        # ==== Returns ====
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+
+        def describe_engine_default_parameters(family, opts={})
+          request({
+            'Action'                 => 'DescribeEngineDefaultParameters',
+            'DBParameterGroupFamily' => family,
+            :parser                  => Fog::Parsers::AWS::RDS::DescribeEngineDefaultParameters.new,
+          }.merge(opts))
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end

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

@@ -49,58 +49,61 @@ module Fog
         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::Compute::AWS::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
 
-          server = self.data[:servers][db_name]
-
-          if server.nil?
-            raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not found")
-          end
-
-          if server["DBInstanceStatus"] != "available"
-            raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not available for modification")
-          end
-
-          db_security_group_names = Array(options.delete("DBSecurityGroups"))
-
-          rds_security_groups = self.data[:security_groups].values
-
-          db_security_groups = db_security_group_names.map do |r, group_name|
-            unless rds_security_groups.find { |sg| sg["DBSecurityGroupName"] == group_name }
-              raise Fog::AWS::RDS::Error.new("InvalidParameterValue => Invalid security group , groupId= , groupName=#{group_name}")
-            end
-            r << {"Status" => "active", "DBSecurityGroupName" => group_name }
-          end
-
-          ec2_security_groups = Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:security_groups].values
-
-          vpc_security_groups = Array(options.delete("VpcSecurityGroups")).map do |group_id|
-            unless ec2_security_groups.find { |sg| sg["groupId"] == group_id }
-              raise Fog::AWS::RDS::Error.new("InvalidParameterValue => Invalid security group , groupId=#{group_id} , groupName=")
             end
-
-            {"Status" => "active", "VpcSecurityGroupId" => group_id }
-          end
-
-          options.merge!(
-            "DBSecurityGroups"  => db_security_groups,
-            "VpcSecurityGroups" => vpc_security_groups
-          )
-
-          if options["NewDBInstanceIdentifier"]
-            options["DBInstanceIdentifier"] = options.delete("NewDBInstanceIdentifier")
+          else
+            raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not found")
           end
-
-          self.data[:modify_time] = Time.now
-          server["PendingModifiedValues"].merge!(options)
-          server["DBInstanceStatus"] = "modifying"
-
-          response.status = 200
-          response.body = {
-            "ResponseMetadata"       => { "RequestId"  => Fog::AWS::Mock.request_id },
-            "ModifyDBInstanceResult" => { "DBInstance" => server }
-          }
-
-          response
         end
       end
     end

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

@@ -42,7 +42,34 @@ module Fog
 
       class Mock
         def modify_db_parameter_group(group_name, parameters)
-          Fog::Mock.not_implemented
+          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
       end
     end

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

@@ -20,8 +20,69 @@ module Fog
       end
 
       class Mock
-        def restore_db_instance_from_db_snapshot(snapshot_id, db_id, options={})
-          Fog::Mock.not_implemented
+        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
       end
     end

data/lib/fog/aws/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module AWS
-    VERSION = "0.8.1"
+    VERSION = "0.9.0"
   end
 end

data/tests/models/rds/cluster_tests.rb

@@ -0,0 +1,54 @@
+Shindo.tests("AWS::RDS | cluster", ["aws", "rds"]) do
+  model_tests(Fog::AWS[:rds].clusters, rds_default_cluster_params) do
+    @cluster_id = @instance.id
+    @instance.wait_for(20*60) { ready? }
+    @cluster_with_final_snapshot = Fog::AWS[:rds].clusters.create(rds_default_cluster_params.merge(:id => uniq_id("fog-snapshot-test"), :backup_retention_period => 1))
+
+    tests("#servers") do
+      returns([]) { @instance.servers }
+    end
+
+    @server = Fog::AWS[:rds].servers.create(rds_default_server_params.reject { |k,v| [:allocated_storage, :master_username, :password, :backup_retention_period].include?(k) }.merge(:engine => "aurora", :cluster_id => @instance.id, :flavor_id => "db.r3.large"))
+    @server.wait_for(20*60) { ready? }
+
+    tests("#servers") do
+      @instance.reload
+      returns([{"DBInstanceIdentifier" => @server.id, "master" => true}]) { @instance.db_cluster_members }
+      returns([@server]) { @instance.servers }
+    end
+
+    tests("#snapshots") do
+      returns([]) { @instance.snapshots }
+
+      snapshot_id = uniq_id("manual-snapshot")
+      snapshot = @instance.snapshots.create(:id => snapshot_id)
+      returns(snapshot_id) { snapshot.id }
+      snapshot.wait_for { ready? }
+      returns([snapshot.id]) { @instance.snapshots.map(&:id) }
+      snapshot.destroy
+    end
+
+    tests("#destroy") do
+      snapshot_id = uniq_id("fog-snapshot")
+
+      @instance.servers.map(&:destroy)
+
+      @cluster_with_final_snapshot.wait_for(20*60) { ready? }
+      @cluster_with_final_snapshot.destroy(snapshot_id)
+
+      snapshot = Fog::AWS[:rds].cluster_snapshots.get(snapshot_id)
+      snapshot.wait_for { ready? }
+      returns(snapshot_id) { snapshot.id }
+      snapshot.destroy
+    end
+
+    after do
+      if cluster = Fog::AWS[:rds].clusters.get(@cluster_id)
+        unless cluster.state = 'deleting'
+          cluster.servers.map(&:destroy)
+          cluster.destroy
+        end
+      end
+    end
+  end
+end

data/tests/models/rds/clusters_tests.rb

@@ -0,0 +1,5 @@
+Shindo.tests("AWS::RDS | clusters", ["aws", "rds"]) do
+  collection_tests(Fog::AWS[:rds].clusters, rds_default_cluster_params) do
+    @instance.wait_for { ready? }
+  end
+end

data/tests/models/rds/helper.rb

@@ -10,3 +10,16 @@ def rds_default_server_params
     :flavor_id               => 'db.m3.medium',
   }
 end
+
+def rds_default_cluster_params
+  {
+    :allocated_storage       => 50,
+    :backup_retention_period => 10,
+    :engine                  => "aurora",
+    :version                 => "5.6.10a",
+    :id                      => uniq_id,
+    :master_username         => "fogclusteruser",
+    :password                => "fogpassword",
+    :flavor_id               => "db.r3.large"
+  }
+end

data/tests/models/rds/server_tests.rb

@@ -6,6 +6,7 @@ Shindo.tests("AWS::RDS | server", ['aws', 'rds']) do
 
     @instance.wait_for(20*60) { ready? }
     @instance_with_encrypted_storage.wait_for(20*60) { ready? }
+    @final_snapshot_id = uniq_id('fog-test-snapshot')
 
     tests("#storage_encrypted") do
       returns(true) { @instance_with_encrypted_storage.storage_encrypted }
@@ -114,12 +115,11 @@ Shindo.tests("AWS::RDS | server", ['aws', 'rds']) do
     replica && replica.destroy
 
     test("Destroying with a final snapshot") do
-      final_snapshot_id = uniq_id('fog-test-snapshot')
 
       @instance_with_final_snapshot.wait_for { ready? }
-      @instance_with_final_snapshot.destroy(final_snapshot_id)
+      @instance_with_final_snapshot.destroy(@final_snapshot_id)
       returns(true, "Final snapshot created") do
-        @final_snapshot = Fog::AWS[:rds].snapshots.get(final_snapshot_id)
+        @final_snapshot = Fog::AWS[:rds].snapshots.get(@final_snapshot_id)
         !@final_snapshot.nil?
       end