fog 1.18.0 → 1.19.0

data/lib/fog/aws/requests/elb/create_load_balancer.rb

@@ -121,6 +121,7 @@ module Fog
             },
             'Instances' => [],
             'ListenerDescriptions' => listeners,
+            'LoadBalancerAttributes' => {'CrossZoneLoadBalancing' => {'Enabled' => false}},
             'LoadBalancerName' => lb_name,
             'Policies' => {
               'AppCookieStickinessPolicies' => [],

data/lib/fog/aws/requests/elb/describe_load_balancer_attributes.rb

@@ -0,0 +1,54 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/describe_load_balancer_attributes'
+
+        # Describe the load balancer attributes
+        # http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_DescribeLoadBalancerAttributes.html
+        # ==== Parameters
+        # * lb_name<~String> - The mnemonic name associated with the LoadBalancer. 
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'DescribeLoadBalancerAttributesResult'<~Hash>:
+        #       * 'LoadBalancerAttributes'<~Hash>
+        #         * 'CrossZoneLoadBalancing'<~Hash>
+        #           * 'Enabled'<~Boolean> - whether crosszone load balancing is enabled
+        def describe_load_balancer_attributes(lb_name)
+          request({
+            'Action'  => 'DescribeLoadBalancerAttributes',
+            'LoadBalancerName' => lb_name,
+            :parser   => Fog::Parsers::AWS::ELB::DescribeLoadBalancerAttributes.new
+          })
+        end
+
+      end
+
+      class Mock
+        def describe_load_balancer_attributes(lb_name = nil, names = [])
+          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
+          attributes = load_balancer['LoadBalancerAttributes']
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'DescribeLoadBalancerAttributesResult' => {
+              'LoadBalancerAttributes' => attributes
+            }
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elb/modify_load_balancer_attributes.rb

@@ -0,0 +1,59 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/empty'
+
+
+        # Sets attributes of the load balancer
+        #
+        # Currently the only attribute that can be set is whether CrossZoneLoadBalancing
+        # is enabled
+        #
+        # http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_ModifyLoadBalancerAttributes.html
+        # ==== Parameters
+        # * lb_name<~String> - Name of the ELB
+        # * options<~Hash>
+        #   * 'CrossZoneLoadBalancing'<~Hash>:
+        #     * 'Enabled'<~Boolean> whether to enable cross zone load balancing
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        def modify_load_balancer_attributes(lb_name, options)
+          attributes = Fog::AWS.serialize_keys 'LoadBalancerAttributes', options
+          request(attributes.merge(
+            'Action'           => 'ModifyLoadBalancerAttributes',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::Empty.new
+          ))
+        end
+
+      end
+
+      class Mock
+        def modify_load_balancer_attributes(lb_name, attributes)
+          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
+
+          if attributes['CrossZoneLoadBalancing']
+            load_balancer['LoadBalancerAttributes'].merge! attributes
+          end
+          
+          response = Excon::Response.new
+
+          response.status = 200
+          response.body = {
+            "ResponseMetadata" => {
+              "RequestId" => Fog::AWS::Mock.request_id
+            }
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -26,6 +26,7 @@ module Fog
         # @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
+        # @param VpcSecurityGroups [Array] A list of VPC Security Groups to authorize on this DB instance
         # 
         # @return [Excon::Response]:
         #   * body [Hash]:
@@ -37,6 +38,10 @@ module Fog
             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'  => 'CreateDBInstance',
             'DBInstanceIdentifier' => db_name,
@@ -105,7 +110,8 @@ module Fog
 #                 "LatestRestorableTime" => nil,
                  "AvailabilityZone" => options["AvailabilityZone"],
                  "DBSubnetGroupName" => options["DBSubnetGroupName"],
-                 "PubliclyAccessible" => options["PubliclyAccessible"]
+                 "PubliclyAccessible" => options["PubliclyAccessible"],
+                 "VpcSecurityGroups" => options["VpcSecurityGroups"],
              }
 
 

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

@@ -33,7 +33,13 @@ module Fog
             raise Fog::AWS::RDS::IdentifierTaken.new("DBSubnetGroupAlreadyExists => The subnet group '#{name}' already exists")
           end
 
-          subnets = subnet_ids.map { |snid| Fog::Compute[:aws].subnets.get(snid) }
+          # collection = Fog::Compute::AWS.new(:aws_access_key_id => 'mock key', :aws_secret_access_key => 'mock secret')
+          collection = Fog::Compute[:aws]
+          subnets = subnet_ids.map do |snid|
+            subnet = collection.subnets.get(snid)
+            raise Fog::AWS::RDS::NotFound.new("InvalidSubnet => The subnet '#{snid}' was not found") if subnet.nil?
+            subnet
+          end
           vpc_id = subnets.first.vpc_id
 
           data = {

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

@@ -0,0 +1,42 @@
+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/storage/delete_multiple_objects.rb

@@ -32,9 +32,10 @@ module Fog
         # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/multiobjectdeleteapi.html
         
         def delete_multiple_objects(bucket_name, object_names, options = {})
+          headers = options.dup
           data = "<Delete>"
-          data << "<Quiet>true</Quiet>" if options.delete(:quiet)
-          version_ids = options.delete('versionId')
+          data << "<Quiet>true</Quiet>" if headers.delete(:quiet)
+          version_ids = headers.delete('versionId')
           object_names.each do |object_name|
             data << "<Object>"
             data << "<Key>#{CGI.escapeHTML(object_name)}</Key>"
@@ -46,7 +47,6 @@ module Fog
           end
           data << "</Delete>"
 
-          headers = options
           headers['Content-Length'] = data.length
           headers['Content-MD5'] = Base64.encode64(Digest::MD5.digest(data)).
                                    gsub("\n", '')
@@ -67,11 +67,13 @@ module Fog
       class Mock # :nodoc:all
 
         def delete_multiple_objects(bucket_name, object_names, options = {})
+          headers = options.dup
+          headers.delete(:quiet)
           response = Excon::Response.new
           if bucket = self.data[:buckets][bucket_name]
             response.status = 200
             response.body = { 'DeleteResult' => [] }
-            version_ids = options.delete('versionId')
+            version_ids = headers.delete('versionId')
             object_names.each do |object_name|
               object_version = version_ids.nil? ? nil : version_ids[object_name]
               response.body['DeleteResult'] << delete_object_helper(bucket,

data/lib/fog/aws/requests/storage/put_bucket.rb

@@ -62,8 +62,11 @@ DATA
           else
             bucket['LocationConstraint'] = nil
           end
-          unless self.data[:buckets][bucket_name]
+          if !self.data[:buckets][bucket_name] || self.region == 'us-east-1'
             self.data[:buckets][bucket_name] = bucket
+          else
+            response.status = 409
+            raise(Excon::Errors.status_error({:expects => 200}, response))
           end
           response
         end

data/lib/fog/aws/sqs.rb

@@ -4,7 +4,7 @@ module Fog
   module AWS
     class SQS < Fog::Service
       extend Fog::AWS::CredentialFetcher::ServiceMethods
-      
+
       requires :aws_access_key_id, :aws_secret_access_key
       recognizes :region, :host, :path, :port, :scheme, :persistent, :aws_session_token, :use_iam_profile, :aws_credentials_expire_at
 
@@ -30,7 +30,7 @@ module Fog
             end
           end
         end
-        
+
         def self.reset
           @data = nil
         end
@@ -123,9 +123,7 @@ module Fog
               :aws_access_key_id  => @aws_access_key_id,
               :aws_session_token  => @aws_session_token,
               :hmac               => @hmac,
-              :host               => @host,
               :path               => path || @path,
-              :port               => @port,
               :version            => '2009-02-01'
             }
           )

data/lib/fog/aws/storage.rb

@@ -140,6 +140,10 @@ module Fog
 
         def signed_url(params, expires)
           expires = expires.to_i
+          if @aws_session_token
+            params[:headers]||= {}
+            params[:headers]['x-amz-security-token'] = @aws_session_token
+          end
           signature = signature(params, expires)
           params = request_params(params)
 
@@ -174,6 +178,14 @@ module Fog
 
         # NOTE: differs from Fog::AWS.escape by NOT escaping `/`
         def escape(string)
+          unless @unf_loaded_or_warned
+            begin
+              require('unf/normalizer')
+            rescue LoadError
+              Fog::Logger.warning("Unable to load the 'unf' gem. Your AWS strings may not be properly encoded.")
+            end
+            @unf_loaded_or_warned = true
+          end
           string = defined?(::UNF::Normalizer) ? ::UNF::Normalizer.normalize(string, :nfc) : string
           string.gsub(/([^a-zA-Z0-9_.\-~\/]+)/) {
             "%" + $1.unpack("H2" * $1.bytesize).join("%").upcase
@@ -405,6 +417,8 @@ module Fog
           @connection_options     = options[:connection_options] || {}
           @persistent = options.fetch(:persistent, false)
 
+          @path_style = options[:path_style]  || false
+
           if @endpoint = options[:endpoint]
             endpoint = URI.parse(@endpoint)
             @host = endpoint.host
@@ -415,7 +429,6 @@ module Fog
             @host       = options[:host]        || region_to_host(@region)
             @scheme     = options[:scheme]      || DEFAULT_SCHEME
             @port       = options[:port]        || DEFAULT_SCHEME_PORT[@scheme]
-            @path_style = options[:path_style]  || false
           end
         end
 

data/lib/fog/bluebox/compute.rb

@@ -83,7 +83,7 @@ module Fog
           })
 
           begin
-            response = @connection.request(params.merge!({:host => @host}))
+            response = @connection.request(params)
           rescue Excon::Errors::HTTPStatusError => error
             raise case error
             when Excon::Errors::NotFound

data/lib/fog/brightbox/compute.rb

@@ -166,7 +166,7 @@ module Fog
           _request
         end
 
-      private
+        private
 
         def _request
           raise Fog::Errors::MockNotImplemented
@@ -236,7 +236,7 @@ module Fog
           _wrapped_request(method, path, expected_responses, parameters)
         end
 
-      private
+        private
 
         # Wrapped request is the non-standard form of request introduced by mistake
         #
@@ -256,20 +256,18 @@ module Fog
 
           # Select the account to scope for this request
           account = scoped_account(parameters.fetch(:account_id, nil))
-          if account
-            request_options[:query] = { :account_id => account }
-          end
+          request_options[:query] = { :account_id => account } if account
 
           request_options[:body] = Fog::JSON.encode(parameters) unless parameters.empty?
 
           response = make_request(request_options)
 
-          # FIXME We should revert to returning the Excon::Request after a suitable
+          # FIXME: We should revert to returning the Excon::Request after a suitable
           # configuration option is in place to switch back to this incorrect behaviour
-          unless response.body.empty?
-            Fog::JSON.decode(response.body)
-          else
+          if response.body.empty?
             response
+          else
+            Fog::JSON.decode(response.body)
           end
         end
 

data/lib/fog/brightbox/compute/image_selector.rb

@@ -32,7 +32,7 @@ module Fog
             img["official"] == true &&
               img["arch"] == "i686" &&
               img["name"] =~ /ubuntu/i
-          end.sort do |a,b|
+          end.sort do |a, b|
             # Reverse sort so "raring" > "precise" and "13.10" > "13.04"
             b["name"].downcase <=> a["name"].downcase
           end.first["id"]

data/lib/fog/brightbox/compute/shared.rb

@@ -63,7 +63,7 @@ module Fog
           # Request account can be changed at anytime and changes behaviour of future requests
           @scoped_account      = @configured_account
 
-          credential_options   = {:username => username, :password => password}
+          credential_options   = { :username => username, :password => password }
           @credentials         = CredentialSet.new(client_id, client_secret, credential_options)
 
           # If existing tokens have been cached, allow continued use of them in the service
@@ -175,7 +175,7 @@ module Fog
           @default_image_id = Fog.credentials[:brightbox_default_image] || select_default_image
         end
 
-      private
+        private
 
         # This makes a request of the API based on the configured setting for
         # token management.
@@ -200,13 +200,11 @@ module Fog
         #
         # @return [Excon::Response]
         def managed_token_request(options)
-          begin
-            get_access_token unless access_token_available?
-            response = authenticated_request(options)
-          rescue Excon::Errors::Unauthorized
-            get_access_token
-            response = authenticated_request(options)
-          end
+          get_access_token unless access_token_available?
+          authenticated_request(options)
+        rescue Excon::Errors::Unauthorized
+          get_access_token
+          authenticated_request(options)
         end
 
         # This request makes an authenticated request of the API using currently
@@ -221,7 +219,7 @@ module Fog
           headers = options[:headers] || {}
           headers.merge!("Authorization" => "OAuth #{@credentials.access_token}", "Content-Type" => "application/json")
           options[:headers] = headers
-          # TODO This is just a wrapper around a call to Excon::Connection#request
+          # TODO: This is just a wrapper around a call to Excon::Connection#request
           #   so can be extracted from Compute by passing in the connection,
           #   credentials and options
           @connection.request(options)

data/lib/fog/brightbox/models/compute/api_client.rb

@@ -14,7 +14,7 @@ module Fog
           options = {
             :name => name,
             :description => description
-          }.delete_if {|k,v| v.nil? || v == "" }
+          }.delete_if { |k, v| v.nil? || v == "" }
           data = service.create_api_client(options)
           merge_attributes(data)
           true