fog-aws 0.0.5

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

@@ -0,0 +1,66 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/describe_db_snapshots'
+
+        # Describe all or specified db snapshots
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBSnapshots.html
+        # ==== Parameters
+        # * DBInstanceIdentifier <~String> - ID of instance to retrieve information for. if absent information for all instances is returned
+        # * DBSnapshotIdentifier <~String> - ID of snapshot to retrieve information for. if absent information for all snapshots is returned
+        # * SnapshotType       <~String> - type of snapshot to retrive (automated|manual)
+        # * 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_snapshots(opts={})
+          params = {}
+          params['SnapshotType'] = opts[:type] if opts[:type]
+          params['DBInstanceIdentifier'] = opts[:identifier] if opts[:identifier]
+          params['DBSnapshotIdentifier'] = 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'  => 'DescribeDBSnapshots',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBSnapshots.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/describe_db_subnet_groups'
+
+        # This API returns a list of DBSubnetGroup descriptions. If a DBSubnetGroupName is specified, the list will contain only
+        # the descriptions of the specified DBSubnetGroup
+        # http://docs.amazonwebservices.com/AmazonRDS/2012-01-15/APIReference/API_DescribeDBSubnetGroups.html
+        # ==== Parameters
+        # * DBSubnetGroupName <~String> - The name of a specific database subnet group to return details for.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_db_subnet_groups(name = nil, opts = {})
+          params = {}
+          if opts[:marker]
+            params['Marker'] = opts[:marker]
+          end
+          if name
+            params['DBSubnetGroupName'] = name
+          end
+          if opts[:max_records]
+            params['MaxRecords'] = opts[:max_records]
+          end
+
+          request({
+            'Action'  => 'DescribeDBSubnetGroups',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBSubnetGroups.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/describe_event_subscriptions'
+
+        # Describe all or specified event notifications
+        # http://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeEventSubscriptions.html
+        # === Parameters
+        # * Marker <~String> - An optional pagination token provided by a previous DescribeOrderableDBInstanceOptions request
+        # * MaxRecords <~String> - The maximum number of records to include in the response (20-100)
+        # * SubscriptionName <~String> - The name of the RDS event notification subscription you want to describe
+        # === Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>
+        def describe_event_subscriptions(options={})
+          if options[:max_records]
+            params['MaxRecords'] = options[:max_records]
+          end
+
+          request({
+            'Action' => 'DescribeEventSubscriptions',
+            :parser  => Fog::Parsers::AWS::RDS::DescribeEventSubscriptions.new
+          }.merge(options))
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/event_list'
+
+        # Returns a list of service events
+		#
+        # For more information see:
+		# http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeEvents.html
+		#
+        # === Parameters (optional)
+        # * options <~Hash> (optional):
+        # *  :start_time <~DateTime> - starting time for event records
+        # *  :end_time <~DateTime> - ending time for event records
+        # *  :duration <~Integer> - The number of minutes to retrieve events for
+		#			Default = 60 Mins
+        # *  :marker <~String> - marker provided in the previous request
+        # *  :max_records <~Integer> - the maximum number of records to include
+		#			Default = 100
+		#			Constraints: min = 20, maximum 100
+        # *  :source_identifier <~String> - identifier of the event source
+        # *  :source_type <~DateTime> - event type, one of:
+        #      (db-instance | db-parameter-group | db-security-group | db-snapshot)
+        # === Returns
+        # * response <~Excon::Response>:
+        #   * body <~Hash>
+        def describe_events(options = {})
+          request(
+            'Action'            => 'DescribeEvents',
+            'StartTime'         => options[:start_time],
+            'EndTime'           => options[:end_time],
+            'Duration'          => options[:duration],
+            'Marker'            => options[:marker],
+            'MaxRecords'        => options[:max_records],
+            'SourceIdentifier'  => options[:source_identifier],
+            'SourceType'        => options[:source_type],
+            :parser => Fog::Parsers::AWS::RDS::EventListParser.new
+          )
+        end
+      end
+
+      class Mock
+        def describe_events
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/describe_orderable_db_instance_options'
+
+        # Describe all or specified load db instances
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html
+        # ==== Parameters
+        # * Engine <~String> - The name of the engine to retrieve DB Instance options for. Required.
+        # * Options <~Hash> - Hash of options. Optional. The following keys are used:
+        #   * :db_instance_class <~String> - Filter available offerings matching the specified DB Instance class. Optional.
+        #   * :engine_version <~String> - Filters available offerings matching the specified engine version. Optional.
+        #   * :license_model <~String> - Filters available offerings matching the specified license model. 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.
+        #   * :vpc <~Boolean> - Filter to show only the available VPC or non-VPC offerings. Optional.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_orderable_db_instance_options(engine=nil, opts={})
+          params = {}
+          params['Engine'] = engine if engine
+          params['DBInstanceClass'] = opts[:db_instance_class] if opts[:db_instance_class]
+          params['EngineVersion'] = opts[:engine_version] if opts[:engine_version]
+          params['LicenseModel'] = opts[:license_model] if opts[:license_model]
+          params['Marker'] = opts[:marker] if opts[:marker]
+          params['MaxRecords'] = opts[:max_records] if opts[:max_records]
+          params['Vpc'] = opts[:vpc] if opts[:vpc]
+
+          request({
+            'Action'  => 'DescribeOrderableDBInstanceOptions',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeOrderableDBInstanceOptions.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        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', 'ProvisionedIopsCapable' => true},
+                                      {'Name' => 'us-east-1c', 'ProvisionedIopsCapable' => true},
+                                      {'Name' => 'us-east-1d', 'ProvisionedIopsCapable' => false},
+                                      {'Name' => 'us-east-1e', 'ProvisionedIopsCapable' => true}],
+                                   'DBInstanceClass' => size,
+                                   '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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/download_db_logfile_portion'
+
+        # Retrieve a portion of a log file of a db instance
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DownloadDBLogFilePortion.html
+        # ==== Parameters
+        # * DBInstanceIdentifier <~String> - ID of instance to retrieve information for. Required.
+        # * LogFileName <~String> - The name of the log file to be downloaded. Required.
+        # * Options <~Hash> - Hash of options. Optional. The following keys are used:
+        #   * :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.
+        #   * :number_of_lines <~Integer> - The number of lines to download. Optional.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def download_db_logfile_portion(identifier=nil, filename=nil, opts={})
+          params = {}
+          params['DBInstanceIdentifier'] = identifier if identifier
+          params['LogFileName'] = filename if filename
+          params['Marker'] = opts[:marker] if opts[:marker]
+          params['MaxRecords'] = opts[:max_records] if opts[:max_records]
+          params['NumberOfLines'] = opts[:number_of_lines] if opts[:number_of_lines]
+
+          request({
+            'Action'  => 'DownloadDBLogFilePortion',
+            :parser   => Fog::Parsers::AWS::RDS::DownloadDBLogFilePortion.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/tag_list_parser'
+
+        # returns a Hash of tags for a database instance
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_ListTagsForResource.html
+        # ==== Parameters
+        # * rds_id <~String> - name of the RDS instance whose tags are to be retrieved
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def list_tags_for_resource(rds_id)
+          request(
+            'Action'        => 'ListTagsForResource',
+            'ResourceName'  => "arn:aws:rds:#{@region}:#{owner_id}:db:#{rds_id}",
+            :parser         => Fog::Parsers::AWS::RDS::TagListParser.new
+          )
+        end
+      end
+
+      class Mock
+        def list_tags_for_resource(rds_id)
+          response = Excon::Response.new
+          if server = self.data[:servers][rds_id]
+            response.status = 200
+            response.body = {
+              "ListTagsForResourceResult" =>
+                {"TagList" =>  self.data[:tags][rds_id]}
+            }
+            response
+          else
+            raise Fog::AWS::RDS::NotFound.new("DBInstance #{rds_id} not found")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/modify_db_instance'
+
+        # modifies a database instance
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html
+        # ==== Parameters
+        # * DBInstanceIdentifier <~String> - name of the db instance to modify
+        # * ApplyImmediately <~Boolean> - whether to apply the changes immediately or wait for the next maintenance window
+        #
+        # * AllocatedStorage  <~Integer> Storage space, in GB
+        # * AllowMajorVersionUpgrade <~Boolean> Must be set to true if EngineVersion specifies a different major version
+        # * AutoMinorVersionUpgrade <~Boolean> Indicates that minor version upgrades will be applied automatically to the DB Instance during the maintenance window
+        # * BackupRetentionPeriod  <~Integer> 0-8 The number of days to retain automated backups.
+        # * DBInstanceClass <~String> The new compute and memory capacity of the DB Instanc
+        # * DBParameterGroupName <~String> The name of the DB Parameter Group to apply to this DB Instance
+        # * DBSecurityGroups <~Array> A list of DB Security Groups to authorize on this DB Instance
+        # * EngineVersion <~String> The version number of the database engine to upgrade to.
+        # * Iops <~Integer> IOPS rate
+        # * MasterUserPassword  <~String> The new password for the DB Instance master user
+        # * MultiAZ <~Boolean> Specifies if the DB Instance is a Multi-AZ deployment
+        # * PreferredBackupWindow <~String> The daily time range during which automated backups are created if automated backups are enabled
+        # * PreferredMaintenanceWindow <~String> The weekly time range (in UTC) during which system maintenance can occur, which may result in an outage
+        # * VpcSecurityGroups <~Array> A list of VPC Security Group IDs to authorize on this DB instance
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def modify_db_instance(db_name, apply_immediately, 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'  => 'ModifyDBInstance',
+            'DBInstanceIdentifier' => db_name,
+            'ApplyImmediately' => apply_immediately,
+            :parser   => Fog::Parsers::AWS::RDS::ModifyDBInstance.new,
+          }.merge(options))
+        end
+      end
+
+      class Mock
+        def modify_db_instance(db_name, apply_immediately, options={})
+          response = Excon::Response.new
+          if self.data[:servers][db_name]
+            if self.data[:servers][db_name]["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
+              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
+      end
+    end
+  end
+end