fog-aws 0.0.5

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

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/delete_db_subnet_group'
+
+        # Deletes a db subnet group
+        # http://docs.aws.amazon.com/AmazonRDS/2013-09-09/APIReference/API_DeleteDBSubnetGroup.html
+        # ==== Parameters
+        # * DBSubnetGroupName <~String> - The name for the DB Subnet Group. This value is stored as a lowercase string. Must contain no more than 255 alphanumeric characters or hyphens. Must not be "Default".
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def delete_db_subnet_group(name)
+          params = { 'Action'  => 'DeleteDBSubnetGroup',
+            'DBSubnetGroupName' => name,
+            :parser   => Fog::Parsers::AWS::RDS::DeleteDBSubnetGroup.new }
+          request(params)
+        end
+      end
+
+      class Mock
+        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
+
+          response.body = {
+            'ResponseMetadata'=>{ 'RequestId'=> Fog::AWS::Mock.request_id },
+            'return' => true,
+          }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/delete_event_subscription'
+
+        # deletes an event subscription
+        # http://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteEventSubscription.html
+        # === Parameters
+        # * SubscriptionName <~String> - The name of the subscription to delete
+        # === Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>
+
+        def delete_event_subscription(name)
+          request({
+            'Action'           => 'DeleteEventSubscription',
+            'SubscriptionName' => name,
+            :parser            => Fog::Parsers::AWS::RDS::DeleteEventSubscription.new
+          })
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/describe_db_engine_versions'
+
+        def describe_db_engine_versions(opts={})
+          params = {}
+          params['DBParameterGroupFamily'] = opts[:db_parameter_group_family] if opts[:db_parameter_group_family]
+          params['DefaultOnly'] = opts[:default_only] if opts[:default_only]
+          params['Engine'] = opts[:engine] if opts[:engine]
+          params['EngineVersion'] = opts[:engine_version] if opts[:engine_version]
+          params['Marker'] = opts[:marker] if opts[:marker]
+          params['MaxRecords'] = opts[:max_records] if opts[:max_records]
+
+          request({
+            'Action'  => 'DescribeDBEngineVersions',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBEngineVersions.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def describe_db_engine_versions(opts={})
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/describe_db_instances'
+
+        # Describe all or specified load db instances
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html
+        # ==== Parameters
+        # * DBInstanceIdentifier <~String> - ID of instance to retrieve information for. if absent information for all instances is returned
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_db_instances(identifier=nil, opts={})
+          params = {}
+          params['DBInstanceIdentifier'] = identifier if identifier
+          if opts[:marker]
+            params['Marker'] = opts[:marker]
+          end
+          if opts[:max_records]
+            params['MaxRecords'] = opts[:max_records]
+          end
+
+          request({
+            'Action'  => 'DescribeDBInstances',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBInstances.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def describe_db_instances(identifier=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
+
+          server_set.each do |server|
+             case server["DBInstanceStatus"]
+             when "creating"
+               if Time.now - server['InstanceCreateTime'] >= Fog::Mock.delay * 2
+                 region = "us-east-1"
+                 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
+                  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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/describe_db_log_files'
+
+        # Describe log files for a DB instance
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBLogFiles.html
+        # ==== Parameters
+        # * DBInstanceIdentifier <~String> - ID of instance to retrieve information for. Required.
+        # * Options <~Hash> - Hash of options. Optional. The following keys are used:
+        #   * :file_last_written <~Long> - Filter available log files for those written after this time. Optional.
+        #   * :file_size <~Long> - Filters the available log files for files larger than the specified size. Optional.
+        #   * :filename_contains <~String> - Filters the available log files for log file names that contain the specified string. Optional.
+        #   * :marker <~String> - The pagination token provided in the previous request. If this parameter is specified the response includes only records beyond the marker, up to MaxRecords. Optional.
+        #   * :max_records <~Integer> - The maximum number of records to include in the response. If more records exist, a pagination token is included in the response. Optional.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_db_log_files(rds_id=nil, opts={})
+          params = {}
+          params['DBInstanceIdentifier'] = rds_id if rds_id
+          params['Marker'] = opts[:marker] if opts[:marker]
+          params['MaxRecords'] = opts[:max_records] if opts[:max_records]
+          params['FilenameContains'] = opts[:filename_contains] if opts[:filename_contains]
+          params['FileSize'] = opts[:file_size] if opts[:file_size]
+          params['FileLastWritten'] = opts[:file_last_written] if opts[:file_last_written]
+
+          request({
+            'Action'  => 'DescribeDBLogFiles',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBLogFiles.new(rds_id)
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/describe_db_parameter_groups'
+
+        # This API returns a list of DBParameterGroup descriptions. If a DBParameterGroupName is specified, the list will contain only the descriptions of the specified DBParameterGroup
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBParameterGroups.html
+        # ==== Parameters
+        # * DBParameterGroupName <~String> - The name of a specific database parameter group to return details for.
+        # * Source <~String> - The parameter types to return. user | system | engine-default
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_db_parameter_groups(name=nil, opts={})
+          params={}
+          if opts[:marker]
+            params['Marker'] = opts[:marker]
+          end
+          if name
+            params['DBParameterGroupName'] = name
+          end
+          if opts[:max_records]
+            params['MaxRecords'] = opts[:max_records]
+          end
+
+          request({
+            'Action'  => 'DescribeDBParameterGroups',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBParameterGroups.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/describe_db_parameters'
+
+        # Describe  parameters from a parameter group
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBParameters.html
+        # ==== Parameters
+        # * DBParameterGroupName <~String> - name of parameter group to retrieve parameters for
+        # * Source <~String> - The parameter types to return. user | system | engine-default
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_db_parameters(name, opts={})
+          params={}
+          if opts[:marker]
+            params['Marker'] = opts[:marker]
+          end
+          if opts[:source]
+            params['Source'] = opts[:source]
+          end
+          if opts[:max_records]
+            params['MaxRecords'] = opts[:max_records]
+          end
+
+          request({
+            'Action'  => 'DescribeDBParameters',
+            'DBParameterGroupName' => name,
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBParameters.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def describe_db_parameters(name, opts={})
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/describe_db_reserved_instances'
+
+        # Describe all or specified load db instances
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html
+        # ==== Parameters
+        # * DBInstanceIdentifier <~String> - ID of instance to retrieve information for. if absent information for all instances is returned
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_db_reserved_instances(identifier=nil, opts={})
+          params = {}
+          params['ReservedDBInstanceId'] = identifier if identifier
+          if opts[:marker]
+            params['Marker'] = opts[:marker]
+          end
+          if opts[:max_records]
+            params['MaxRecords'] = opts[:max_records]
+          end
+
+          request({
+            'Action'  => 'DescribeReservedDBInstances',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBReservedInstances.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def describe_db_reserved_instances(identifier=nil, opts={})
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/describe_db_security_groups'
+
+        # Describe all or specified db security groups
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/index.html?API_DescribeDBSecurityGroups.html
+        # ==== Parameters
+        # * DBSecurityGroupName <~String> - The name of the DB Security Group to return details for.
+        # * Marker               <~String> - An optional marker provided in the previous DescribeDBInstances request
+        # * MaxRecords           <~Integer> - Max number of records to return (between 20 and 100)
+        # Only one of DBInstanceIdentifier or DBSnapshotIdentifier can be specified
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_db_security_groups(opts={})
+          opts = {'DBSecurityGroupName' => opts} if opts.is_a?(String)
+
+          request({
+            'Action'  => 'DescribeDBSecurityGroups',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBSecurityGroups.new
+          }.merge(opts))
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end