gapinc-fog 1.12.1.1 → 1.12.1.2

data/lib/fog/google/requests/compute/list_machine_types.rb

@@ -12,10 +12,11 @@ module Fog
 
       class Real
 
-        def list_machine_types
+        def list_machine_types(zone_name)
           api_method = @compute.machine_types.list
           parameters = {
-            'project' => 'google'
+            'project' => @project,
+            'zone' => zone_name,
           }
 
           result = self.build_result(api_method, parameters)

data/lib/fog/hp/storage.rb

@@ -10,8 +10,11 @@ module Fog
       recognizes  :persistent, :connection_options
       recognizes  :hp_use_upass_auth_style, :hp_auth_version, :user_agent
       recognizes  :hp_access_key, :hp_account_id  # :hp_account_id is deprecated use hp_access_key instead
+      
+      # :os_account_meta_temp_url_key is an OpenStack specific setting used to generate temporary urls.
+      recognizes  :os_account_meta_temp_url_key
 
-      secrets     :hp_secret_key
+      secrets     :hp_secret_key, :os_account_meta_temp_url_key
 
       model_path 'fog/hp/models/storage'
       model       :directory
@@ -167,14 +170,26 @@ module Fog
           encoded_path = "#{path}/#{Fog::HP.escape(container)}/#{Fog::HP.escape(object)}"
 
           string_to_sign = "#{method}\n#{expires}\n#{sig_path}"
-          # Only works with 1.9+ Not compatible with 1.8.7
-          #signed_string = Digest::HMAC.hexdigest(string_to_sign, @hp_secret_key, Digest::SHA1)
-          # Compatible with 1.8.7 onwards
-          hmac = OpenSSL::HMAC.new(@hp_secret_key, OpenSSL::Digest::SHA1.new)
-          signed_string = hmac.update(string_to_sign).hexdigest
-
-          signature = @hp_tenant_id.to_s + ":" + @hp_access_key.to_s + ":" + signed_string
-          signature = Fog::HP.escape(signature)
+                    
+          signature = nil          
+          
+          # HP uses a different strategy to create the signature that is passed to swift than OpenStack.
+          # As the HP provider is broadly used by OpenStack users the OpenStack strategy is applied when
+          # the @os_account_meta_temp_url_key is given.
+          if @os_account_meta_temp_url_key then
+            hmac      = OpenSSL::HMAC.new(@os_account_meta_temp_url_key, OpenSSL::Digest::SHA1.new)
+            signature= hmac.update(string_to_sign).hexdigest
+          else
+            # Only works with 1.9+ Not compatible with 1.8.7
+            #signed_string = Digest::HMAC.hexdigest(string_to_sign, @hp_secret_key, Digest::SHA1)
+          
+            # Compatible with 1.8.7 onwards          
+            hmac = OpenSSL::HMAC.new(@hp_secret_key, OpenSSL::Digest::SHA1.new)
+            signed_string = hmac.update(string_to_sign).hexdigest
+            
+            signature     = @hp_tenant_id.to_s + ":" + @hp_access_key.to_s + ":" + signed_string
+            signature     = Fog::HP.escape(signature)
+          end
 
           # generate the temp url using the signature and expiry
           "#{scheme}://#{host}:#{port}#{encoded_path}?temp_url_sig=#{signature}&temp_url_expires=#{expires}"
@@ -217,6 +232,7 @@ module Fog
           end
           @hp_secret_key = options[:hp_secret_key]
           @hp_tenant_id = options[:hp_tenant_id]
+          @os_account_meta_temp_url_key = options[:os_account_meta_temp_url_key]        
         end
 
         def data
@@ -254,6 +270,7 @@ module Fog
           options[:hp_service_type] = "Object Storage"
           @hp_tenant_id = options[:hp_tenant_id]
           @hp_avl_zone  = options[:hp_avl_zone]
+          @os_account_meta_temp_url_key = options[:os_account_meta_temp_url_key]
 
           ### Make the authentication call
           if (auth_version == :v2)

data/lib/fog/{core/json.rb → json.rb}

@@ -1,6 +1,18 @@
-require 'multi_json'
+require "multi_json"
 
 module Fog
+
+  # @note Extracting JSON components out of core is a work in progress.
+  #
+  # The {JSON} module includes functionality that is common between APIs using
+  # JSON to send and receive data.
+  #
+  # The intent is to provide common code for provider APIs using JSON but not
+  # require it for those using XML.
+  #
+  # @todo Add +require "fog/json" and/or +include Fog::JSON+ to providers using
+  #   its services
+  #
   module JSON
 
     def self.sanitize(data)
@@ -28,6 +40,5 @@ module Fog
     def self.decode(obj)
       MultiJson.decode(obj)
     end
-
   end
 end

data/lib/fog/openstack/models/compute/metadata.rb

@@ -18,7 +18,7 @@ module Fog
           requires :parent
           metadata = service.list_metadata(collection_name, @parent.id).body['metadata']
           metas = []
-          metadata.each_pair {|k,v| metas << {"key" => k, "value" => v} }
+          metadata.each_pair {|k,v| metas << {"key" => k, "value" => v} } unless metadata.nil?
           load(metas)
         end
 

data/lib/fog/openstack/models/image/images.rb

@@ -16,7 +16,7 @@ module Fog
         end
 
         def find_by_id(id)
-          self.find {|image| image.id == id}
+          all.find {|image| image.id == id}
         end
         alias_method :get, :find_by_id
 

data/lib/fog/openstack/requests/compute/detach_volume.rb

@@ -17,7 +17,8 @@ module Fog
 
         def detach_volume(server_id, attachment_id)
           response = Excon::Response.new
-          if self.data[:volumes][attachment_id]['attachments'].reject! { |attachment| attachment['serverId'] == server_id }
+          if self.data[:volumes][attachment_id] &&
+             self.data[:volumes][attachment_id]['attachments'].reject! { |attachment| attachment['serverId'] == server_id }
             response.status = 202
             response
           else

data/lib/fog/openstack/requests/compute/list_security_groups.rb

@@ -23,7 +23,7 @@ module Fog
 
           groups = if server_id then
                      server_group_names =
-                       self.data[:server_security_group_map][server_id]
+                       Array(self.data[:server_security_group_map][server_id])
 
                      server_group_names.map do |name|
                        security_groups.find do |sg|

data/lib/fog/rackspace.rb

@@ -96,6 +96,11 @@ module Fog
       end
     end
 
+    def self.json_response?(response)
+      return false unless response && response.headers
+      response.headers['Content-Type'] =~ %r{application/json}i ? true : false
+    end
+
     def self.normalize_url(endpoint)
       return nil unless endpoint
       str = endpoint.chomp " "

data/lib/fog/rackspace/block_storage.rb

@@ -87,40 +87,25 @@ module Fog
           @connection = Fog::Connection.new(endpoint_uri.to_s, @persistent, @connection_options)
         end
 
-        def request(params)
-          begin
-            response = @connection.request(params.merge!({
-              :headers  => {
-                'Content-Type' => 'application/json',
-                'Accept' => 'application/json',
-                'X-Auth-Token' => auth_token
-              }.merge!(params[:headers] || {}),
-              :host     => endpoint_uri.host,
-              :path     => "#{endpoint_uri.path}/#{params[:path]}"
-            }))
-          rescue Excon::Errors::NotFound => error
-            raise NotFound.slurp(error, region)
-          rescue Excon::Errors::BadRequest => error
-            raise BadRequest.slurp error
-          rescue Excon::Errors::InternalServerError => error
-            raise InternalServerError.slurp error
-          rescue Excon::Errors::HTTPStatusError => error
-            raise ServiceError.slurp error
-          end
-          unless response.body.empty?
-            response.body = Fog::JSON.decode(response.body)
-          end
-          response
+        def request(params, parse_json = true, &block)
+          super(params, parse_json, &block)
+        rescue Excon::Errors::NotFound => error
+          raise NotFound.slurp(error, region)
+        rescue Excon::Errors::BadRequest => error
+          raise BadRequest.slurp error
+        rescue Excon::Errors::InternalServerError => error
+          raise InternalServerError.slurp error
+        rescue Excon::Errors::HTTPStatusError => error
+          raise ServiceError.slurp error
         end
 
-        def authenticate
-          options = {
+        def authenticate(options={})
+          super({
             :rackspace_api_key => @rackspace_api_key,
             :rackspace_username => @rackspace_username,
             :rackspace_auth_url => @rackspace_auth_url,
             :connection_options => @connection_options
-          }
-          super(options)
+          })
         end
 
         def service_name

data/lib/fog/rackspace/cdn.rb

@@ -152,30 +152,16 @@ module Fog
           true
         end        
 
-        def request(params, parse_json = true)
-          begin
-            response = @connection.request(params.merge!({
-              :headers  => {
-                'Content-Type' => 'application/json',
-                'Accept' => 'application/json',
-                'X-Auth-Token' => auth_token
-              }.merge!(params[:headers] || {}),
-              :host     => endpoint_uri.host,
-              :path     => "#{endpoint_uri.path}/#{params[:path]}",
-            }))
-          rescue Excon::Errors::NotFound => error
-            raise Fog::Storage::Rackspace::NotFound.slurp(error, region)
-          rescue Excon::Errors::BadRequest => error
-            raise Fog::Storage::Rackspace::BadRequest.slurp error
-          rescue Excon::Errors::InternalServerError => error
-            raise Fog::Storage::Rackspace::InternalServerError.slurp error
-          rescue Excon::Errors::HTTPStatusError => error
-            raise Fog::Storage::Rackspace::ServiceError.slurp error
-          end
-          if !response.body.empty? && parse_json && response.headers['Content-Type'] =~ %r{application/json}
-            response.body = Fog::JSON.decode(response.body)
-          end
-          response
+        def request(params, parse_json = true, &block)
+          super(params, parse_json, &block)
+        rescue Excon::Errors::NotFound => error
+          raise Fog::Storage::Rackspace::NotFound.slurp(error, region)
+        rescue Excon::Errors::BadRequest => error
+          raise Fog::Storage::Rackspace::BadRequest.slurp error
+        rescue Excon::Errors::InternalServerError => error
+          raise Fog::Storage::Rackspace::InternalServerError.slurp error
+        rescue Excon::Errors::HTTPStatusError => error
+          raise Fog::Storage::Rackspace::ServiceError.slurp error
         end
         
         private 

data/lib/fog/rackspace/compute.rb

@@ -190,7 +190,6 @@ module Fog
           @rackspace_servicenet = options[:rackspace_servicenet]
           @rackspace_auth_token = options[:rackspace_auth_token]
           @rackspace_endpoint = Fog::Rackspace.normalize_url(options[:rackspace_compute_v1_url] || options[:rackspace_management_url])
-          @rackspace_must_reauthenticate = false
           @connection_options = options[:connection_options] || {}
           authenticate
           Excon.defaults[:ssl_verify_peer] = false if service_net?
@@ -202,56 +201,29 @@ module Fog
           @connection.reset
         end
 
-        def request(params)
-          begin
-            response = @connection.request(params.merge({
-              :headers  => {
-                'Content-Type' => 'application/json',
-                'X-Auth-Token' => auth_token
-              }.merge!(params[:headers] || {}),
-              :host     => endpoint_uri.host,
-              :path     => "#{endpoint_uri.path}/#{params[:path]}",
-            }))
-          rescue Excon::Errors::Unauthorized => error
-            if error.response.body != 'Bad username or password' # token expiration
-              @rackspace_must_reauthenticate = true
-              authenticate
-              retry
-            else # bad credentials
-              raise error
-            end
-          rescue Excon::Errors::HTTPStatusError => error
-            raise case error
-            when Excon::Errors::NotFound
-              NotFound.slurp(error, region)
-            else
-              error
-            end
-          end
-          unless response.body.empty?
-            response.body = Fog::JSON.decode(response.body)
-          end
-          response
+        def request(params, parse_json = true, &block)
+          super(params, parse_json, &block)
+        rescue Excon::Errors::NotFound => error
+          raise NotFound.slurp(error, region)
+        rescue Excon::Errors::BadRequest => error
+          raise BadRequest.slurp error
+        rescue Excon::Errors::InternalServerError => error
+          raise InternalServerError.slurp error
+        rescue Excon::Errors::HTTPStatusError => error
+          raise ServiceError.slurp error
         end
 
-
         def service_net?
            @rackspace_servicenet == true
         end
 
-         def authenticate
-           if @rackspace_must_reauthenticate || @rackspace_auth_token.nil?
-             options = {
-               :rackspace_api_key  => @rackspace_api_key,
-               :rackspace_username => @rackspace_username,
-               :rackspace_auth_url => @rackspace_auth_url,
-               :connection_options => @connection_options
-             }
-             super(options)
-           else
-             @auth_token = @rackspace_auth_token
-             @uri = URI.parse(@rackspace_endpoint)
-           end
+         def authenticate(options={})
+            super({
+             :rackspace_api_key  => @rackspace_api_key,
+             :rackspace_username => @rackspace_username,
+             :rackspace_auth_url => @rackspace_auth_url,
+             :connection_options => @connection_options
+           })
          end
 
          def service_name

data/lib/fog/rackspace/compute_v2.rb

@@ -139,45 +139,25 @@ module Fog
           @connection = Fog::Connection.new(endpoint_uri.to_s, @persistent, @connection_options)
         end
 
-        def request(params)
-          begin
-            response = @connection.request(params.merge!({
-              :headers  => {
-                'Content-Type' => 'application/json',
-                'Accept' => 'application/json',
-                'X-Auth-Token' => auth_token
-              }.merge!(params[:headers] || {}),
-              :host     => endpoint_uri.host,
-              :path     => "#{endpoint_uri.path}/#{params[:path]}"
-            }))
-          rescue Excon::Errors::NotFound => error
-            raise NotFound.slurp(error, region)
-          rescue Excon::Errors::BadRequest => error
-            raise BadRequest.slurp error
-          rescue Excon::Errors::InternalServerError => error
-            raise InternalServerError.slurp error
-          rescue Excon::Errors::HTTPStatusError => error
-            raise ServiceError.slurp error
-          end
-
-          unless response.body.empty?
-            begin
-              response.body = Fog::JSON.decode(response.body)
-            rescue MultiJson::DecodeError => e
-              response.body = {}
-            end
-          end
-          response
+        def request(params, parse_json = true, &block)
+          super(params, parse_json, &block)
+        rescue Excon::Errors::NotFound => error
+          raise NotFound.slurp(error, region)
+        rescue Excon::Errors::BadRequest => error
+          raise BadRequest.slurp error
+        rescue Excon::Errors::InternalServerError => error
+          raise InternalServerError.slurp error
+        rescue Excon::Errors::HTTPStatusError => error
+          raise ServiceError.slurp error
         end
 
-        def authenticate
-          options = {
+        def authenticate(options={})
+          super({
             :rackspace_api_key => @rackspace_api_key,
             :rackspace_username => @rackspace_username,
             :rackspace_auth_url => @rackspace_auth_url,
             :connection_options => @connection_options
-          }
-          super(options)
+          })
         end
 
         def service_name

data/lib/fog/rackspace/databases.rb

@@ -85,45 +85,29 @@ module Fog
           @connection = Fog::Connection.new(endpoint_uri.to_s, @persistent, @connection_options)
         end
 
-        def request(params)
-          begin
-            response = @connection.request(params.merge!({
-              :headers  => {
-                'Content-Type' => 'application/json',
-                'Accept' => 'application/json',
-                'X-Auth-Token' => auth_token
-              }.merge!(params[:headers] || {}),
-              :host     => endpoint_uri.host,
-              :path     => "#{endpoint_uri.path}/#{params[:path]}"
-            }))
-          rescue Excon::Errors::NotFound => error
-            raise NotFound.slurp(error, region)
-          rescue Excon::Errors::BadRequest => error
-            raise BadRequest.slurp error
-          rescue Excon::Errors::InternalServerError => error
-            raise InternalServerError.slurp error
-          rescue Excon::Errors::HTTPStatusError => error
-            raise ServiceError.slurp error
-          end
-          unless response.body.empty?
-            response.body = Fog::JSON.decode(response.body)
-          end
-          response
+        def request(params, parse_json = true, &block)
+          super(params, parse_json, &block)
+        rescue Excon::Errors::NotFound => error
+          raise NotFound.slurp(error, region)
+        rescue Excon::Errors::BadRequest => error
+          raise BadRequest.slurp error
+        rescue Excon::Errors::InternalServerError => error
+          raise InternalServerError.slurp error
+        rescue Excon::Errors::HTTPStatusError => error
+          raise ServiceError.slurp error
         end
 
         def endpoint_uri(service_endpoint_url=nil)
           @uri = super(@rackspace_endpoint || service_endpoint_url, :rackspace_database_url)
         end
 
-        def authenticate
-          options = {
+        def authenticate(options={})
+          super({
             :rackspace_api_key  => @rackspace_api_key,
             :rackspace_username => @rackspace_username,
             :rackspace_auth_url => @rackspace_auth_url,
             :connection_options => @connection_options
-          }
-
-          super(options)
+          })
         end
 
         private