fog 1.12.1 → 1.13.0

data/lib/fog/aws/beanstalk.rb

@@ -131,16 +131,14 @@ module Fog
                 :parser     => parser
             })
           rescue Excon::Errors::HTTPStatusError => error
-            if match = error.message.match(/(?:.*<Code>(.*)<\/Code>)(?:.*<Message>(.*)<\/Message>)/m)
-              raise case match[1].split('.').last
-                      when 'InvalidParameterValue'
-                        Fog::AWS::ElasticBeanstalk::InvalidParameterError.slurp(error, match[2])
-                      else
-                        Fog::AWS::ElasticBeanstalk::Error.slurp(error, "#{match[1]} => #{match[2]}")
-                    end
-            else
-              raise error
-            end
+            match = Fog::AWS::Errors.match_error(error)
+            raise if match.empty?
+            raise case match[:code]
+                  when 'InvalidParameterValue'
+                    Fog::AWS::ElasticBeanstalk::InvalidParameterError.slurp(error, match[:message])
+                  else
+                    Fog::AWS::ElasticBeanstalk::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
+                  end
           end
 
         end

data/lib/fog/aws/cloud_formation.rb

@@ -98,7 +98,7 @@ module Fog
           )
 
           begin
-            response = @connection.request({
+            @connection.request({
               :body       => body,
               :expects    => 200,
               :idempotent => idempotent,
@@ -108,19 +108,16 @@ module Fog
               :parser     => parser
             })
           rescue Excon::Errors::HTTPStatusError => error
-            if match = error.message.match(/(?:.*<Code>(.*)<\/Code>)(?:.*<Message>(.*)<\/Message>)/m)
-              raise case match[1].split('.').last
-              when 'NotFound', 'ValidationError'
-                Fog::AWS::CloudFormation::NotFound.slurp(error, match[2])
-              else
-                Fog::AWS::CloudFormation::Error.slurp(error, "#{match[1]} => #{match[2]}")
-              end
-            else
-              raise error
-            end
+            match = Fog::AWS::Errors.match_error(error)
+            raise if match.empty?
+            raise case match[:code]
+                  when 'NotFound', 'ValidationError'
+                    Fog::AWS::CloudFormation::NotFound.slurp(error, match[:message])
+                  else
+                    Fog::AWS::CloudFormation::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
+                  end
           end
 
-          response
         end
 
       end

data/lib/fog/aws/compute.rb

@@ -392,16 +392,14 @@ module Fog
               :parser     => parser
             })
         rescue Excon::Errors::HTTPStatusError => error
-          if match = error.message.match(/(?:.*<Code>(.*)<\/Code>)(?:.*<Message>(.*)<\/Message>)/m)
-            raise case match[1].split('.').last
-                  when 'NotFound', 'Unknown'
-                    Fog::Compute::AWS::NotFound.slurp(error, match[2])
-                  else
-                    Fog::Compute::AWS::Error.slurp(error, "#{match[1]} => #{match[2]}")
-                  end
-          else
-            raise error
-          end
+          match = Fog::AWS::Errors.match_error(error)
+          raise if match.empty?
+          raise case match[:code]
+                when 'NotFound', 'Unknown'
+                  Fog::Compute::AWS::NotFound.slurp(error, match[:message])
+                else
+                  Fog::Compute::AWS::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
+                end
         end
 
       end

data/lib/fog/aws/credential_fetcher.rb

@@ -1,4 +1,5 @@
-require 'fog/core/json'
+require "fog/json"
+
 module Fog
   module AWS
     module CredentialFetcher
@@ -14,7 +15,7 @@ module Fog
 
               session = Fog::JSON.decode(role_data)
               credentials = {}
-              credentials[:aws_access_key_id] = session['AccessKeyId']  
+              credentials[:aws_access_key_id] = session['AccessKeyId']
               credentials[:aws_secret_access_key] = session['SecretAccessKey']
               credentials[:aws_session_token] = session['Token']
               credentials[:aws_credentials_expire_at] = Time.xmlschema session['Expiration']
@@ -31,7 +32,7 @@ module Fog
       end
 
       module ConnectionMethods
-        
+
         def refresh_credentials_if_expired
           refresh_credentials if credentials_expired?
         end
@@ -39,8 +40,8 @@ module Fog
         private
 
         def credentials_expired?
-          @use_iam_profile && 
-            (!@aws_credentials_expire_at || 
+          @use_iam_profile &&
+            (!@aws_credentials_expire_at ||
              (@aws_credentials_expire_at && Fog::Time.now > @aws_credentials_expire_at - 15)) #new credentials become available from around 5 minutes before expiration time
         end
 
@@ -61,4 +62,3 @@ module Fog
     end
   end
 end
-

data/lib/fog/aws/elasticache.rb

@@ -94,7 +94,7 @@ module Fog
           )
 
           begin
-            response = @connection.request({
+            @connection.request({
               :body       => body,
               :expects    => 200,
               :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
@@ -104,24 +104,20 @@ module Fog
               :parser     => parser
             })
           rescue Excon::Errors::HTTPStatusError => error
-            if match = error.message.match(/(?:.*<Code>(.*)<\/Code>?)/m)
-              case match[1]
-              when 'CacheSecurityGroupNotFound', 'CacheParameterGroupNotFound',
-                'CacheClusterNotFound'
-                raise Fog::AWS::Elasticache::NotFound
-              when 'CacheSecurityGroupAlreadyExists'
-                raise Fog::AWS::Elasticache::IdentifierTaken
-              when 'InvalidParameterValue'
-                raise Fog::AWS::Elasticache::InvalidInstance
-              else
-                raise
-              end
-            else
-              raise
-            end
+            match = Fog::AWS::Errors.match_error(error)
+            raise if match.empty?
+            raise case match[:code]
+                  when 'CacheSecurityGroupNotFound', 'CacheParameterGroupNotFound', 'CacheClusterNotFound'
+                    Fog::AWS::Elasticache::NotFound.slurp(error, match[:message])
+                  when 'CacheSecurityGroupAlreadyExists'
+                    Fog::AWS::Elasticache::IdentifierTaken.slurp(error, match[:message])
+                  when 'InvalidParameterValue'
+                    Fog::AWS::Elasticache::InvalidInstance.slurp(error, match[:message])
+                  else
+                    Fog::AWS::Elasticache::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
+                  end
           end
 
-          response
         end
 
       end

data/lib/fog/aws/elb.rb

@@ -191,37 +191,35 @@ module Fog
             :parser     => parser
           })
         rescue Excon::Errors::HTTPStatusError => error
-          if match = error.message.match(/(?:.*<Code>(.*)<\/Code>)(?:.*<Message>(.*)<\/Message>)/m)
-            case match[1]
-            when 'CertificateNotFound'
-              raise Fog::AWS::IAM::NotFound.slurp(error, match[2])
-            when 'DuplicateLoadBalancerName'
-              raise Fog::AWS::ELB::IdentifierTaken.slurp(error, match[2])
-            when 'DuplicatePolicyName'
-              raise Fog::AWS::ELB::DuplicatePolicyName.slurp(error, match[2])
-            when 'InvalidInstance'
-              raise Fog::AWS::ELB::InvalidInstance.slurp(error, match[2])
-            when 'InvalidConfigurationRequest'
-              # when do they fucking use this shit?
-              raise Fog::AWS::ELB::InvalidConfigurationRequest.slurp(error, match[2])
-            when 'LoadBalancerNotFound'
-              raise Fog::AWS::ELB::NotFound.slurp(error, match[2])
-            when 'PolicyNotFound'
-              raise Fog::AWS::ELB::PolicyNotFound.slurp(error, match[2])
-            when 'PolicyTypeNotFound'
-              raise Fog::AWS::ELB::PolicyTypeNotFound.slurp(error, match[2])
-            when 'Throttling'
-              raise Fog::AWS::ELB::Throttled.slurp(error, match[2])
-            when 'TooManyPolicies'
-              raise Fog::AWS::ELB::TooManyPolicies.slurp(error, match[2])
-            when 'ValidationError'
-              raise Fog::AWS::ELB::ValidationError.slurp(error, match[2])
-            else
-              raise
-            end
-          else
-            raise
-          end
+          match = Fog::AWS::Errors.match_error(error)
+          raise if match.empty?
+          raise case match[:code]
+                when 'CertificateNotFound'
+                  Fog::AWS::IAM::NotFound.slurp(error, match[:message])
+                when 'DuplicateLoadBalancerName'
+                  Fog::AWS::ELB::IdentifierTaken.slurp(error, match[:message])
+                when 'DuplicatePolicyName'
+                  Fog::AWS::ELB::DuplicatePolicyName.slurp(error, match[:message])
+                when 'InvalidInstance'
+                  Fog::AWS::ELB::InvalidInstance.slurp(error, match[:message])
+                when 'InvalidConfigurationRequest'
+                  # when do they fucking use this shit?
+                  Fog::AWS::ELB::InvalidConfigurationRequest.slurp(error, match[:message])
+                when 'LoadBalancerNotFound'
+                  Fog::AWS::ELB::NotFound.slurp(error, match[:message])
+                when 'PolicyNotFound'
+                  Fog::AWS::ELB::PolicyNotFound.slurp(error, match[:message])
+                when 'PolicyTypeNotFound'
+                  Fog::AWS::ELB::PolicyTypeNotFound.slurp(error, match[:message])
+                when 'Throttling'
+                  Fog::AWS::ELB::Throttled.slurp(error, match[:message])
+                when 'TooManyPolicies'
+                  Fog::AWS::ELB::TooManyPolicies.slurp(error, match[:message])
+                when 'ValidationError'
+                  Fog::AWS::ELB::ValidationError.slurp(error, match[:message])
+                else
+                  Fog::AWS::ELB::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
+                end
         end
       end
     end

data/lib/fog/aws/iam.rb

@@ -208,19 +208,16 @@ module Fog
             :parser     => parser
           })
         rescue Excon::Errors::HTTPStatusError => error
-          if match = error.message.match(/(?:.*<Code>(.*)<\/Code>)(?:.*<Message>(.*)<\/Message>)/m)
-            case match[1]
-            when 'CertificateNotFound', 'NoSuchEntity'
-              raise Fog::AWS::IAM::NotFound.slurp(error, match[2])
-            when 'EntityAlreadyExists', 'KeyPairMismatch', 'LimitExceeded', 'MalformedCertificate', 'ValidationError'
-              raise Fog::AWS::IAM.const_get(match[1]).slurp(error, match[2])
-            else
-              raise Fog::AWS::IAM::Error.slurp(error, "#{match[1]} => #{match[2]}") if match[1]
-              raise
-            end
-          else
-            raise
-          end
+          match = Fog::AWS::Errors.match_error(error)
+          raise if match.empty?
+          raise case match[:code]
+                when 'CertificateNotFound', 'NoSuchEntity'
+                  Fog::AWS::IAM::NotFound.slurp(error, match[:message])
+                when 'EntityAlreadyExists', 'KeyPairMismatch', 'LimitExceeded', 'MalformedCertificate', 'ValidationError'
+                  Fog::AWS::IAM.const_get(match[:code]).slurp(error, match[:message])
+                else
+                  Fog::AWS::IAM::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
+                end
         end
 
       end

data/lib/fog/aws/models/auto_scaling/group.rb

@@ -111,8 +111,7 @@ module Fog
           requires :launch_configuration_name
           requires :max_size
           requires :min_size
-
-          service.create_auto_scaling_group(id, availability_zones, launch_configuration_name, max_size, min_size, options)
+          service.create_auto_scaling_group(id, availability_zones, launch_configuration_name, max_size, min_size, filtered_options(:create_auto_scaling_group))
           reload
         end
 
@@ -132,10 +131,14 @@ module Fog
 
         def update
           requires :id
-          service.update_auto_scaling_group(id, options)
+          service.update_auto_scaling_group(id, filtered_options(:update_auto_scaling_group) )
           reload
         end
 
+        def filtered_options(method)
+          Hash[options.select{|k,_| ExpectedOptions[method].include?(k)}]
+        end
+
         def options
           ret = Hash[self.class.aliases.map { |key, value| [key, send(value)] }]
           ret.delete_if { |key, value| value.nil? }

data/lib/fog/aws/models/compute/spot_request.rb

@@ -95,7 +95,7 @@ module Fog
             'LaunchSpecification.KeyName'                    => key_name,
             'LaunchSpecification.Monitoring.Enabled'         => monitoring,
             'LaunchSpecification.Placement.AvailabilityZone' => availability_zone,
-            'LaunchSpecification.SecurityGroup'              => groups,
+            'LaunchSpecification.SecurityGroupId'            => groups,
             'LaunchSpecification.EbsOptimized'               => ebs_optimized,
             'LaunchSpecification.UserData'                   => user_data,
             'LaunchSpecification.SubnetId'                   => subnet_id,
@@ -106,16 +106,6 @@ module Fog
             'ValidUntil'                                     => valid_until }
           options.delete_if {|key, value| value.nil?}
 
-          # If subnet is defined then this is a Virtual Private Cloud.
-          # subnet & security group cannot co-exist. Attempting to specify
-          # both subnet and groups will cause an error.  Instead please make
-          # use of Security Group Ids when working in a VPC.
-          if subnet_id
-            options.delete('LaunchSpecification.SecurityGroup')
-          else
-            options.delete('LaunchSpecification.SubnetId')
-          end
-
           data = service.request_spot_instances(image_id, flavor_id, price, options).body
           spot_instance_request = data['spotInstanceRequestSet'].first
           spot_instance_request['launchSpecification'].each do |name,value|

data/lib/fog/aws/models/rds/log_file.rb

@@ -0,0 +1,26 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class RDS
+
+      class LogFile < Fog::Model
+
+        attribute :rds_id, :aliases => 'DBInstanceIdentifier'
+        attribute :name, :aliases => 'LogFileName'
+        attribute :size, :aliases => 'Size', :type => :integer
+        attribute :last_written, :aliases => 'LastWritten', :type => :time
+        attribute :content, :aliases => 'LogFileData'
+        attribute :marker, :aliases => 'Marker'
+        attribute :more_content_available, :aliases => 'AdditionalDataPending', :type => :boolean
+
+        def content_excerpt(marker=nil)
+          result = service.download_db_logfile_portion(self.rds_id, self.name, {:marker => marker})
+          merge_attributes(result.body['DownloadDBLogFilePortionResult'])
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/rds/log_files.rb

@@ -0,0 +1,50 @@
+require 'fog/core/collection'
+require 'fog/aws/models/rds/log_file'
+
+module Fog
+  module AWS
+    class RDS
+
+      class LogFiles < Fog::Collection
+        attribute :filters
+        attribute :rds_id
+        model Fog::AWS::RDS::LogFile
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        # This method deliberately returns only a single page of results
+        def all(filters=filters)
+          self.filters.merge!(filters)
+
+          result = service.describe_db_log_files(rds_id, self.filters).body['DescribeDBLogFilesResult']
+          self.filters[:marker] = result['Marker']
+          load(result['DBLogFiles'])
+        end
+
+        def each(filters=filters)
+          if block_given?
+            begin
+              page = self.all(filters)
+              # We need to explicitly use the base 'each' method here on the page, otherwise we get infinite recursion
+              base_each = Fog::Collection.instance_method(:each)
+              base_each.bind(page).call { |log_file| yield log_file }
+            end while self.filters[:marker]
+          end
+          self
+        end
+
+        def get(file_name=nil)
+          if file_name
+            matches = self.select {|log_file| log_file.name.upcase == file_name.upcase}
+            return matches.first unless matches.empty?
+          end
+        rescue Fog::AWS::RDS::NotFound
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/rds/server.rb

@@ -30,6 +30,7 @@ module Fog
         attribute :backup_retention_period, :aliases => 'BackupRetentionPeriod', :type => :integer
         attribute :license_model, :aliases => 'LicenseModel'
         attribute :db_subnet_group_name, :aliases => 'DBSubnetGroupName'
+        attribute :publicly_accessible, :aliases => 'PubliclyAccessible'
 
         attr_accessor :password, :parameter_group_name, :security_group_names, :port
 
@@ -120,7 +121,8 @@ module Fog
             'PreferredBackupWindow'         => preferred_backup_window,
             'MultiAZ'                       => multi_az,
             'LicenseModel'                  => license_model,
-            'DBSubnetGroupName'             => db_subnet_group_name
+            'DBSubnetGroupName'             => db_subnet_group_name,
+            'PubliclyAccessible'            => publicly_accessible
           }
 
           options.delete_if {|key, value| value.nil?}

data/lib/fog/aws/models/rds/snapshot.rb

@@ -18,6 +18,7 @@ module Fog
         attribute  :allocated_storage, :aliases => 'AllocatedStorage', :type => :integer
         attribute  :availability_zone, :aliases => 'AvailabilityZone'
         attribute  :type, :aliases => 'SnapshotType'
+        attribute  :publicly_accessible, :aliases => 'PubliclyAccessible'
 
         def ready?
           state == 'available'

data/lib/fog/aws/models/rds/snapshots.rb

@@ -21,26 +21,33 @@ module Fog
           super
         end
 
-        # This will return a single page based on the current or provided filters,
-        # updating the filters with the marker for the next page.  Calling this repeatedly
-        # will iterate through pages.
+        # This method does NOT return all snapshots. Its implementation deliberately returns a single page
+        # of results for any one call. It will return a single page based on the current or provided filters,
+        # updating the filters with the marker for the next page. Calling this repeatedly will iterate
+        # through pages. See the implementation of each for an example of such iteration.
+        #
+        # It is arguably incorrect for the method not to return all snapshots, particularly considering the
+        # implementation in the corresponding 'elb' files. But this implementation has been released, and
+        # backwards-compatibility requires leaving it as implemented.
         def all(filters = filters)
           self.filters.merge!(filters)
 
-          snapshots = service.describe_db_snapshots(filters)
-          self.filters[:marker] = snapshots.body['DescribeDBSnapshotsResult']['Marker']
-          data = snapshots.body['DescribeDBSnapshotsResult']['DBSnapshots']
-          load(data)
+          page = service.describe_db_snapshots(self.filters).body['DescribeDBSnapshotsResult']
+          self.filters[:marker] = page['Marker']
+          load(page['DBSnapshots'])
         end
 
         # This will execute a block for each snapshot, fetching new pages of snapshots as required.
         def each(filters = filters)
-          begin
-            page = self.all(filters)
-            # We need to explicitly use the base 'each' method here on the page, otherwise we get infinite recursion
-            base_each = Fog::Collection.instance_method(:each)
-            base_each.bind(page).call {|snapshot| yield snapshot}
-          end while self.filters[:marker]
+          if block_given?
+            begin
+              page = self.all(filters)
+              # We need to explicitly use the base 'each' method here on the page, otherwise we get infinite recursion
+              base_each = Fog::Collection.instance_method(:each)
+              base_each.bind(page).call { |snapshot| yield snapshot }
+            end while self.filters[:marker]
+          end
+          self
         end
 
         def get(identity)