fog 1.12.1 → 1.13.0

data/lib/fog/aws/parsers/rds/db_parser.rb

@@ -47,7 +47,7 @@ module Fog
               'DBInstanceStatus', 'DBInstanceIdentifier', 'EngineVersion', 
               'PreferredBackupWindow', 'PreferredMaintenanceWindow', 
               'AvailabilityZone', 'MasterUsername', 'DBName', 'LicenseModel',
-              'DBSubnetGroupName'
+              'DBSubnetGroupName', 'PubliclyAccessible'
               @db_instance[name] = value
             when 'MultiAZ', 'AutoMinorVersionUpgrade'
               if value == 'false'

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

@@ -0,0 +1,44 @@
+module Fog
+  module Parsers
+    module AWS
+      module RDS
+
+        class DescribeDBLogFiles < Fog::Parsers::Base
+
+          attr_reader :rds_id
+
+          def initialize(rds_id)
+            @rds_id = rds_id
+            super()
+          end
+
+          def reset
+            @response = { 'DescribeDBLogFilesResult' => {'DBLogFiles' => []}, 'ResponseMetadata' => {} }
+            fresh_log_file
+          end
+
+          def fresh_log_file
+            @db_log_file = {'DBInstanceIdentifier' => @rds_id}
+          end
+
+          def start_element(name, attrs = [])
+            super
+          end
+
+          def end_element(name)
+            case name
+            when 'LastWritten' then @db_log_file[name] = Time.at(value.to_i / 1000)
+            when 'LogFileName' then @db_log_file[name] = value
+            when 'Size' then @db_log_file[name] = value.to_i
+            when 'DescribeDBLogFilesDetails'
+              @response['DescribeDBLogFilesResult']['DBLogFiles'] << @db_log_file
+              fresh_log_file
+            when 'Marker' then @response['DescribeDBLogFilesResult'][name] = value
+            when 'RequestId' then @response['ResponseMetadata'][name] = value
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module Parsers
+    module AWS
+      module RDS
+
+        class DownloadDBLogFilePortion < Fog::Parsers::Base
+
+          def reset
+            @response = { 'DownloadDBLogFilePortionResult' => {}, 'ResponseMetadata' => {} }
+          end
+
+          def start_element(name, attrs = [])
+            super
+          end
+
+          def end_element(name)
+            key = (name == 'RequestId') ? 'ResponseMetadata' : 'DownloadDBLogFilePortionResult'
+            @response[key][name] = value
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/ses/verify_domain_identity.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Parsers
+    module AWS
+      module SES
+
+        class VerifyDomainIdentity < Fog::Parsers::Base
+
+          def reset
+            @response = { 'ResponseMetadata' => {} }
+          end
+
+          def end_element(name)
+            case name
+            when 'VerificationToken'
+              @response[name] = value
+            when 'RequestId'
+              @response['ResponseMetadata'][name] = value
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/storage/complete_multipart_upload.rb

@@ -11,7 +11,7 @@ module Fog
 
           def end_element(name)
             case name
-            when 'Bucket', 'ETag', 'Key', 'Location'
+            when 'Bucket', 'ETag', 'Key', 'Location', 'Code', 'Message'
               @response[name] = value
             end
           end

data/lib/fog/aws/parsers/sts/assume_role.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Parsers
+    module AWS
+      module STS
+
+        class AssumeRole < Fog::Parsers::Base
+
+          def reset
+            @response = {}
+          end
+
+          def end_element(name)
+            case name
+            when 'SessionToken', 'SecretAccessKey', 'Expiration', 'AccessKeyId'
+              @response[name] = @value.strip
+            when 'Arn', 'AssumedRoleId'
+              @response[name] = @value.strip
+            when 'PackedPolicySize'
+              @response[name] = @value
+            when 'RequestId'
+              @response[name] = @value
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/rds.rb

@@ -10,7 +10,7 @@ module Fog
       class AuthorizationAlreadyExists < Fog::Errors::Error; end
 
       requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at
+      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :version
 
       request_path 'fog/aws/requests/rds'
       request :describe_events
@@ -51,11 +51,16 @@ module Fog
       request :describe_db_subnet_groups
       # TODO: :delete_db_subnet_group, :modify_db_subnet_group
 
+      request :describe_db_log_files
+      request :download_db_logfile_portion
+
       model_path 'fog/aws/models/rds'
       model       :server
       collection  :servers
+
       model       :snapshot
       collection  :snapshots
+
       model       :parameter_group
       collection  :parameter_groups
 
@@ -68,6 +73,9 @@ module Fog
       model       :subnet_group
       collection  :subnet_groups
 
+      model       :log_file
+      collection  :log_files
+
       class Mock
 
         def self.data
@@ -155,6 +163,7 @@ module Fog
           @port       = options[:port]        || 443
           @scheme     = options[:scheme]      || 'https'
           @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
+          @version    = options[:version] || '2012-09-17' #'2011-04-01'
         end
 
         def owner_id
@@ -191,12 +200,12 @@ module Fog
               :host               => @host,
               :path               => @path,
               :port               => @port,
-              :version            => '2012-09-17' #'2011-04-01'
+              :version            => @version
             }
           )
 
           begin
-            response = @connection.request({
+            @connection.request({
               :body       => body,
               :expects    => 200,
               :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
@@ -206,23 +215,27 @@ module Fog
               :parser     => parser
             })
           rescue Excon::Errors::HTTPStatusError => error
-            if match = error.response.body.match(/(?:.*<Code>(.*)<\/Code>)(?:.*<Message>(.*)<\/Message>)/m)
-              case match[1].split('.').last
-              when 'DBInstanceNotFound', 'DBParameterGroupNotFound', 'DBSnapshotNotFound', 'DBSecurityGroupNotFound'
-                raise Fog::AWS::RDS::NotFound.slurp(error, match[2])
-              when 'DBParameterGroupAlreadyExists'
-                raise Fog::AWS::RDS::IdentifierTaken.slurp(error, match[2])
-              when 'AuthorizationAlreadyExists'
-                raise Fog::AWS::RDS::AuthorizationAlreadyExists.slurp(error, match[2])
+            match = Fog::AWS::Errors.match_error(error)
+            if match.empty?
+              case error.message
+              when 'Not Found'
+                raise Fog::AWS::RDS::NotFound.slurp(error, 'RDS Instance not found')
               else
                 raise
               end
             else
-              raise
+              raise case match[:code]
+                    when 'DBInstanceNotFound', 'DBParameterGroupNotFound', 'DBSnapshotNotFound', 'DBSecurityGroupNotFound'
+                      Fog::AWS::RDS::NotFound.slurp(error, match[:message])
+                    when 'DBParameterGroupAlreadyExists'
+                      Fog::AWS::RDS::IdentifierTaken.slurp(error, match[:message])
+                    when 'AuthorizationAlreadyExists'
+                      Fog::AWS::RDS::AuthorizationAlreadyExists.slurp(error, match[:message])
+                    else
+                      Fog::AWS::RDS::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
+                    end
             end
           end
-
-          response
         end
 
       end

data/lib/fog/aws/requests/auto_scaling/create_auto_scaling_group.rb

@@ -63,6 +63,9 @@ module Fog
         # ==== See Also
         # http://docs.amazonwebservices.com/AutoScaling/latest/APIReference/API_CreateAutoScalingGroup.html
         #
+
+        ExpectedOptions[:create_auto_scaling_group] = %w[DefaultCooldown DesiredCapacity HealthCheckGracePeriod HealthCheckType LoadBalancerNames PlacementGroup Tags TerminationPolicies VPCZoneIdentifier]
+
         def create_auto_scaling_group(auto_scaling_group_name, availability_zones, launch_configuration_name, max_size, min_size, options = {})
           options.merge!(AWS.indexed_param('AvailabilityZones.member.%d', [*availability_zones]))
           options.delete('AvailabilityZones')
@@ -94,6 +97,11 @@ module Fog
       class Mock
 
         def create_auto_scaling_group(auto_scaling_group_name, availability_zones, launch_configuration_name, max_size, min_size, options = {})
+          unexpected_options = options.keys - ExpectedOptions[:create_auto_scaling_group]
+          unless unexpected_options.empty?
+            raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
+          end
+
           if self.data[:auto_scaling_groups].has_key?(auto_scaling_group_name)
             raise Fog::AWS::AutoScaling::IdentifierTaken.new("AutoScalingGroup by this name already exists - A group with the name #{auto_scaling_group_name} already exists")
           end

data/lib/fog/aws/requests/auto_scaling/update_auto_scaling_group.rb

@@ -1,7 +1,6 @@
 module Fog
   module AWS
     class AutoScaling
-
       class Real
 
         require 'fog/aws/parsers/auto_scaling/basic'
@@ -52,6 +51,9 @@ module Fog
         # ==== See Also
         # http://docs.amazonwebservices.com/AutoScaling/latest/APIReference/API_UpdateAutoScalingGroup.html
         #
+
+        ExpectedOptions[:update_auto_scaling_group] = %w[AvailabilityZones DefaultCooldown DesiredCapacity HealthCheckGracePeriod HealthCheckType LaunchConfigurationName MaxSize MinSize PlacementGroup TerminationPolicies VPCZoneIdentifier]
+
         def update_auto_scaling_group(auto_scaling_group_name, options = {})
           if availability_zones = options.delete('AvailabilityZones')
             options.merge!(AWS.indexed_param('AvailabilityZones.member.%d', [*availability_zones]))
@@ -71,6 +73,11 @@ module Fog
       class Mock
 
         def update_auto_scaling_group(auto_scaling_group_name, options = {})
+          unexpected_options = options.keys - ExpectedOptions[:update_auto_scaling_group]
+          unless unexpected_options.empty?
+            raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
+          end
+
           unless self.data[:auto_scaling_groups].has_key?(auto_scaling_group_name)
             raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
           end

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

@@ -13,7 +13,7 @@ module Fog
         # * options<~Hash>
         #   * 'SnapshotId'<~String> - Optional, snapshot to create volume from
         #   * 'VolumeType'<~String> - Optional, volume type. standard or io1, default is standard.
-        #   * 'Iops'<~Integer> - Number of IOPS the volume supports. Required if VolumeType is io1, must be between 1 and 1000.
+        #   * 'Iops'<~Integer> - Number of IOPS the volume supports. Required if VolumeType is io1, must be between 1 and 4000.
         #
         # ==== Returns
         # * response<~Excon::Response>:
@@ -83,8 +83,8 @@ module Fog
                 raise Fog::Compute::AWS::Error.new("VolumeIOPSLimit => Volume iops of #{iops} is too low; minimum is 100.")
               end
 
-              if iops > 2000
-                raise Fog::Compute::AWS::Error.new("VolumeIOPSLimit => Volume iops of #{iops} is too high; maximum is 2000.")
+              if iops > 4000
+                raise Fog::Compute::AWS::Error.new("VolumeIOPSLimit => Volume iops of #{iops} is too high; maximum is 4000.")
               end
             end
 

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

@@ -25,6 +25,7 @@ module Fog
         # @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 PubliclyAcccesible [Boolean] Whether an RDS instance inside of the VPC subnet should have a public-facing endpoint
         # 
         # @return [Excon::Response]:
         #   * body [Hash]:
@@ -103,7 +104,8 @@ module Fog
 #                 "ReadReplicaSourceDBInstanceIdentifier" => nil,
 #                 "LatestRestorableTime" => nil,
                  "AvailabilityZone" => options["AvailabilityZone"],
-                 "DBSubnetGroupName" => options["DBSubnetGroupName"]
+                 "DBSubnetGroupName" => options["DBSubnetGroupName"],
+                 "PubliclyAccessible" => options["PubliclyAccessible"]
              }
 
 

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

@@ -0,0 +1,67 @@
+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/download_db_logfile_portion.rb

@@ -0,0 +1,63 @@
+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