gapinc-fog 1.12.1.1 → 1.12.1.2

data/Rakefile

@@ -53,20 +53,15 @@ require "tasks/test_task"
 Fog::Rake::TestTask.new
 
 namespace :test do
+  mock = 'true' || ENV['FOG_MOCK']
   task :travis do
-    [true].each do |mock|
       sh("export FOG_MOCK=#{mock} && bundle exec shindont")
-    end
   end
   task :vsphere do
-    [true].each do |mock|
       sh("export FOG_MOCK=#{mock} && bundle exec shindont tests/vsphere")
-    end
   end
   task :openvz do
-    [true].each do |mock|
       sh("export FOG_MOCK=#{mock} && bundle exec shindont tests/openvz")
-    end
   end
 end
 
@@ -194,7 +189,8 @@ require "tasks/changelog_task"
 Fog::Rake::ChangelogTask.new
 
 task :coveralls_push_workaround do
-  if Gem::Version.new(RUBY_VERSION) > Gem::Version.new('1.9')
+  ENV['COVERAGE'] = 'false' if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('1.9')
+  unless ENV['COVERAGE'] == 'false'
     require 'coveralls/rake/task'
     Coveralls::RakeTask.new
     Rake::Task["coveralls:push"].invoke

data/bin/fog

@@ -1,7 +1,29 @@
 #!/usr/bin/env ruby
+
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'fog'))
+require 'optparse'
 require 'irb'
 require 'yaml'
+
+options = OptionParser.new do |opts|
+  opts.banner = 'usage: fog [options] CREDENTIAL'
+
+  opts.on('-C', '--credentials-path FILE', 'Path to the credentials file') do |file|
+    Fog.credentials_path = file
+  end
+
+  opts.on_tail('-v', '--version', 'Prints the version') do
+    puts Fog::VERSION
+    exit
+  end
+
+  opts.on_tail('-h', '--help', 'Prints this message') do
+    puts opts
+    exit
+  end
+end
+options.parse!
+
 Fog.credential = ARGV.first ? ARGV.first.to_sym : nil
 Fog.mock! if ENV['FOG_MOCK']
 if Fog.credentials.empty?

data/fog.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'gapinc-fog'
-  s.version           = '1.12.1.1'
+  s.version           = '1.12.1.2'
   s.date              = '2013-06-10'
   s.rubyforge_project = 'fog'
 

data/lib/fog/aws.rb

@@ -301,5 +301,16 @@ module Fog
       end
       options
     end
+
+    module Errors
+      def self.match_error(error)
+        matcher = lambda {|s| s.match(/(?:.*<Code>(.*)<\/Code>)(?:.*<Message>(.*)<\/Message>)/m)}
+        [error.message, error.response.body].each(&Proc.new {|s|
+          match = matcher.call(s)
+          return {:code => match[1].split('.').last, :message => match[2]} if match
+        })
+        {} # we did not match the message or response body
+      end
+    end
   end
 end

data/lib/fog/aws/auto_scaling.rb

@@ -143,7 +143,7 @@ module Fog
 
         def _request(body, idempotent, parser)
           begin
-            response = @connection.request({
+            @connection.request({
               :body       => body,
               :expects    => 200,
               :idempotent => idempotent,
@@ -153,24 +153,19 @@ module Fog
               :parser     => parser
             })
           rescue Excon::Errors::HTTPStatusError => error
-            if match = error.message.match(/(?:.*<Code>(.*)<\/Code>)(?:.*<Message>(.*)<\/Message>)/m)
-              case match[1]
-              when 'AlreadyExists'
-                #raise Fog::AWS::AutoScaling::IdentifierTaken.new(match[2])
-                raise Fog::AWS::AutoScaling::IdentifierTaken.slurp(error, match[2])
-              when 'ResourceInUse'
-                raise Fog::AWS::AutoScaling::ResourceInUse.slurp(error, match[2])
-              when 'ValidationError'
-                raise Fog::AWS::AutoScaling::ValidationError.slurp(error, match[2])
-              else
-                raise Fog::Compute::AWS::Error.slurp(error, "#{match[1]} => #{match[2]}")
-              end
-            else
-             raise
-            end
+            match = Fog::AWS::Errors.match_error(error)
+            raise if match.empty?
+            raise case match[:code]
+                  when 'AlreadyExists'
+                    Fog::AWS::AutoScaling::IdentifierTaken.slurp(error, match[:message])
+                  when 'ResourceInUse'
+                    Fog::AWS::AutoScaling::ResourceInUse.slurp(error, match[:message])
+                  when 'ValidationError'
+                    Fog::AWS::AutoScaling::ValidationError.slurp(error, match[:message])
+                  else
+                    Fog::AWS::AutoScaling::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
+                  end
           end
-
-          response
         end
 
         def setup_credentials(options)

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/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/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/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