fog 1.12.1 → 1.13.0

data/lib/fog/openstack/requests/metering/list_resources.rb

@@ -0,0 +1,32 @@
+module Fog
+  module Metering
+    class OpenStack
+      class Real
+
+        def list_resources(options = {})
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :path     => 'resources'
+          )
+        end
+
+      end
+
+      class Mock
+
+        def list_resources(options = {})
+          response = Excon::Response.new
+          response.status = 200
+          response.body = [{
+            'resource_id'=>'glance',
+            'project_id'=>'d646b40dea6347dfb8caee2da1484c56',
+            'user_id'=>'1d5fd9eda19142289a60ed9330b5d284',
+            'metadata'=>{}}]
+          response
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/openstack/requests/volume/create_volume.rb

@@ -12,7 +12,8 @@ module Fog
             }
           }
 
-          vanilla_options = ['snapshot_id']
+          vanilla_options = [:snapshot_id, :imageRef, :volume_type,
+            :source_volid]
           vanilla_options.select{|o| options[o]}.each do |key|
             data['volume'][key] = options[key]
           end
@@ -38,7 +39,8 @@ module Fog
               'display_description' => description,
               'size'                => size,
               'status'              => 'creating',
-              'snapshot_id'         => options["snapshot_id"] || nil,
+              'snapshot_id'         => options[:snapshot_id] || nil,
+              'image_id'            => options[:imageRef] || nil,
               'volume_type'         => nil,
               'availability_zone'   => 'nova',
               'created_at'          => Time.now,

data/lib/fog/rackspace.rb

@@ -28,7 +28,7 @@ module Fog
             unless error.response.body.empty?
               begin
                 data = Fog::JSON.decode(error.response.body)
-                message = data.values.first ? data.values.first['message'] : data['message']
+                message = extract_message(data)
               rescue  => e
                 Fog::Logger.warning("Received exception '#{e}' while decoding>> #{error.response.body}")
                 message = error.response.body
@@ -42,6 +42,16 @@ module Fog
           new_error.instance_variable_set(:@status_code, status_code)
           new_error
         end
+
+        private
+
+        def self.extract_message(data)
+          if data.is_a?(Hash)
+            message = data.values.first['message'] if data.values.first.is_a?(Hash)
+            message ||= data['message']
+          end
+          message || data.inspect
+        end
       end
 
       class InternalServerError < ServiceError; end
@@ -96,6 +106,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

data/lib/fog/rackspace/dns.rb

@@ -6,6 +6,12 @@ module Fog
     class Rackspace < Fog::Service
       include Fog::Rackspace::Errors
 
+      class ServiceError < Fog::Rackspace::Errors::ServiceError; end
+      class InternalServerError < Fog::Rackspace::Errors::InternalServerError; end
+      class BadRequest < Fog::Rackspace::Errors::BadRequest; end
+      class Conflict < Fog::Rackspace::Errors::Conflict; end
+      class ServiceUnavailable < Fog::Rackspace::Errors::ServiceUnavailable; end
+
       class CallbackError < Fog::Errors::Error
         attr_reader :response, :message, :details
         def initialize(response)
@@ -95,9 +101,6 @@ module Fog
 
           deprecation_warnings(options)
 
-          @connection_options[:headers] ||= {}
-          @connection_options[:headers].merge!({ 'Content-Type' => 'application/json', 'X-Auth-Token' => auth_token })
-
           @persistent = options[:persistent] || false
           @connection = Fog::Connection.new(endpoint_uri.to_s, @persistent, @connection_options)
         end
@@ -108,29 +111,32 @@ module Fog
 
         private
 
-        def request(params)
-          #TODO - Unify code with other rackspace services
+        def request(params, parse_json = true, &block)
           begin
-            response = @connection.request(params.merge!({
-              :path     => "#{endpoint_uri.path}/#{params[:path]}"
-            }))
-          rescue Excon::Errors::BadRequest => error
-            raise Fog::Rackspace::Errors::BadRequest.slurp error
-          rescue Excon::Errors::Conflict => error
-            raise Fog::Rackspace::Errors::Conflict.slurp error
+            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::ServiceUnavailable => error
-            raise Fog::Rackspace::Errors::ServiceUnavailable.slurp error
-          end
-          unless response.body.empty?
-            response.body = Fog::JSON.decode(response.body)
+            raise ServiceUnavailable.slurp error
+          rescue Excon::Errors::Conflict => error
+            raise Conflict.slurp error
+          rescue Excon::Errors::HTTPStatusError => error
+            raise ServiceError.slurp error
           end
-          response
         end
 
         def array_to_query_string(arr)
-          arr.collect {|k,v| "#{k}=#{v}" }.join('&')
+          return "" unless arr
+          query_array = arr.collect do | k, v |
+            val_str = v.is_a?(Array) ? v.join(",") : v.to_s
+            "#{k}=#{val_str}"
+          end
+
+          query_array.join('&')
         end
 
         def validate_path_fragment(name, fragment)
@@ -158,15 +164,13 @@ module Fog
           @auth_token = credentials['X-Auth-Token']
         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
       end
     end