gapinc-fog 1.12.1.2.1 → 1.14.0

data/lib/fog/openstack/requests/network/get_quotas.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+
+        def get_quotas
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :path     => "/quotas"
+          )
+        end
+
+      end
+
+      class Mock
+
+        def get_quotas
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            'quotas' => self.data[:quotas]
+          }
+          response
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/openstack/requests/network/update_quota.rb

@@ -0,0 +1,33 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+
+        def update_quota(tenant_id, options = {})
+          request(
+            :body     => Fog::JSON.encode({ 'quota' => options} ),
+            :expects  => 200,
+            :method   => 'PUT',
+            :path     => "/quotas/#{tenant_id}"
+          )
+        end
+
+      end
+
+      class Mock
+
+        def update_quota(tenant_id, options = {})
+          self.data[:quota_updated] = self.data[:quota].merge options
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = { 'quota' => self.data[:quota_updated] }
+          response
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/fog/openstack/requests/storage/put_object.rb

@@ -11,19 +11,22 @@ module Fog
         # * data<~String|File> - data to upload
         # * options<~Hash> - config headers for object. Defaults to {}.
         #
-        def put_object(container, object, data, options = {})
+        def put_object(container, object, data, options = {}, &block)
           data = Fog::Storage.parse_data(data)
           headers = data[:headers].merge!(options)
-          request(
-            :body       => data[:body],
+
+          params = block_given? ? { :request_block => block } : { :body => data[:body] }
+
+          params.merge!(
             :expects    => 201,
-            :idempotent => true,
+            :idempotent => !params[:request_block],
             :headers    => headers,
             :method     => 'PUT',
             :path       => "#{Fog::OpenStack.escape(container)}/#{Fog::OpenStack.escape(object)}"
           )
-        end
 
+          request(params)
+        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

@@ -12,10 +12,11 @@ module Fog
 
     module Errors
       class ServiceError < Fog::Errors::Error
-        attr_reader :response_data, :status_code
+        attr_reader :response_data, :status_code, :transaction_id
 
         def to_s
-          status_code ? "[HTTP #{status_code}] #{super}" : super
+          status = status_code ? "HTTP #{status_code}" : "HTTP <Unknown>"
+          "[#{status} | #{transaction_id}] #{super}"
         end
 
         def self.slurp(error)
@@ -28,7 +29,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
@@ -40,8 +41,24 @@ module Fog
           new_error = super(error, message)
           new_error.instance_variable_set(:@response_data, data)
           new_error.instance_variable_set(:@status_code, status_code)
+          new_error.set_transaction_id(error, service)
           new_error
         end
+
+        private
+
+        def set_transaction_id(error, service)
+          return unless service && service.respond_to?(:request_id_header) && error.response
+          @transaction_id = error.response.headers[service.request_id_header]
+        end
+
+        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
@@ -57,7 +74,9 @@ module Fog
           unless new_error.response_data.nil? or new_error.response_data['badRequest'].nil?
             new_error.instance_variable_set(:@validation_errors, new_error.response_data['badRequest']['validationErrors'])
           end
-          new_error
+
+          new_error.instance_variable_set(:@status_code, status_code)
+          new_error.set_transaction_id(error, service)
         end
       end
     end
@@ -71,6 +90,7 @@ module Fog
     service(:load_balancers,   'rackspace/load_balancers',    'LoadBalancers')
     service(:identity,         'rackspace/identity',          'Identity')
     service(:databases,        'rackspace/databases',         'Databases')
+    service(:monitoring,       'rackspace/monitoring',        'Monitoring')
 
     def self.authenticate(options, connection_options = {})
       rackspace_auth_url = options[:rackspace_auth_url]

data/lib/fog/rackspace/block_storage.rb

@@ -90,13 +90,13 @@ module Fog
         def request(params, parse_json = true, &block)
           super(params, parse_json, &block)
         rescue Excon::Errors::NotFound => error
-          raise NotFound.slurp(error, region)
+          raise NotFound.slurp(error, self)
         rescue Excon::Errors::BadRequest => error
-          raise BadRequest.slurp error
+          raise BadRequest.slurp(error, self)
         rescue Excon::Errors::InternalServerError => error
-          raise InternalServerError.slurp error
+          raise InternalServerError.slurp(error, self)
         rescue Excon::Errors::HTTPStatusError => error
-          raise ServiceError.slurp error
+          raise ServiceError.slurp(error, self)
         end
 
         def authenticate(options={})
@@ -116,6 +116,10 @@ module Fog
           @rackspace_region
         end
 
+        def request_id_header
+          "X-Compute-Request-Id"
+        end
+
         def endpoint_uri(service_endpoint_url=nil)
           @uri = super(@rackspace_endpoint || service_endpoint_url, :rackspace_block_storage_url)
         end

data/lib/fog/rackspace/cdn.rb

@@ -31,6 +31,10 @@ module Fog
           @rackspace_region
         end
 
+        def request_id_header
+          "X-Trans-Id"
+        end
+
         def endpoint_uri(service_endpoint_url=nil)
           @uri = super(@rackspace_cdn_url || service_endpoint_url, :rackspace_cdn_url)
         end
@@ -115,6 +119,10 @@ module Fog
         include Base
 
         def initialize(options={})
+          # api_key and username missing from instance variable sets
+          @rackspace_api_key = options[:rackspace_api_key]
+          @rackspace_username = options[:rackspace_username]
+          
           @connection_options = options[:connection_options] || {}
           @rackspace_auth_url = options[:rackspace_auth_url]
           @rackspace_cdn_url = options[:rackspace_cdn_url]
@@ -155,13 +163,13 @@ module Fog
         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)
+          raise Fog::Storage::Rackspace::NotFound.slurp(error, self)
         rescue Excon::Errors::BadRequest => error
-          raise Fog::Storage::Rackspace::BadRequest.slurp error
+          raise Fog::Storage::Rackspace::BadRequest.slurp(error, self)
         rescue Excon::Errors::InternalServerError => error
-          raise Fog::Storage::Rackspace::InternalServerError.slurp error
+          raise Fog::Storage::Rackspace::InternalServerError.slurp(error, self)
         rescue Excon::Errors::HTTPStatusError => error
-          raise Fog::Storage::Rackspace::ServiceError.slurp error
+          raise Fog::Storage::Rackspace::ServiceError.slurp(error, self)
         end
         
         private 
@@ -172,6 +180,15 @@ module Fog
           @auth_token = credentials['X-Auth-Token']
         end
 
+        # Fix for invalid auth_token, likely after 24 hours.
+        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
       end
     end
   end

data/lib/fog/rackspace/compute_v2.rb

@@ -54,6 +54,8 @@ module Fog
       collection :attachments
       model :network
       collection :networks
+      model :key_pair
+      collection :key_pairs
 
       request_path 'fog/rackspace/requests/compute_v2'
       request :list_servers
@@ -97,6 +99,11 @@ module Fog
       request :create_network
       request :delete_network
 
+      request :list_keypairs
+      request :create_keypair
+      request :delete_keypair
+      request :get_keypair
+
       class Mock < Fog::Rackspace::Service
         include Fog::Rackspace::MockData
 
@@ -142,13 +149,13 @@ module Fog
         def request(params, parse_json = true, &block)
           super(params, parse_json, &block)
         rescue Excon::Errors::NotFound => error
-          raise NotFound.slurp(error, region)
+          raise NotFound.slurp(error, self)
         rescue Excon::Errors::BadRequest => error
-          raise BadRequest.slurp error
+          raise BadRequest.slurp(error, self)
         rescue Excon::Errors::InternalServerError => error
-          raise InternalServerError.slurp error
+          raise InternalServerError.slurp(error, self)
         rescue Excon::Errors::HTTPStatusError => error
-          raise ServiceError.slurp error
+          raise ServiceError.slurp(error, self)
         end
 
         def authenticate(options={})
@@ -164,6 +171,10 @@ module Fog
           :cloudServersOpenStack
         end
 
+        def request_id_header
+          "X-Compute-Request-Id"
+        end
+
         def region
           @rackspace_region
         end

data/lib/fog/rackspace/errors.rb

@@ -5,20 +5,27 @@ module Fog
       def self.included(mod)
         mod.class_eval <<-'EOS', __FILE__, __LINE__
           class NotFound < Fog::Service::NotFound
-            attr_reader :region, :status_code
+            attr_reader :region, :status_code, :transaction_id
 
             def to_s
-              status = status_code ? "[HTTP #{status_code}] " : ""
+              status = status_code ? "HTTP #{status_code}" : "HTTP <Unknown>"
               message = region ? "resource not found in #{region} region" : super
-              "#{status}#{message}"
+              "[#{status} | #{transaction_id}] #{message}"
             end
 
-            def self.slurp(error, region=nil)
+            def self.slurp(error, service=nil)
               exception = NotFound.new
-              exception.instance_variable_set(:@region, region)
+              exception.instance_variable_set(:@region, service.region) if service && service.respond_to?(:region)
               exception.instance_variable_set(:@status_code, error.response.status) rescue nil
+              exception.set_transaction_id(error, service)
               exception
             end
+
+            def set_transaction_id(error, service)
+              return unless service && service.respond_to?(:request_id_header) && error.response
+              @transaction_id = error.response.headers[service.request_id_header]
+            end
+
           end
         EOS
       end

data/lib/fog/rackspace/mock_data.rb

@@ -8,10 +8,11 @@ module Fog
         @@data ||= Hash.new do |hash, key|
           hash[key] = begin
             #Compute V2
-            flavor_id = Fog.credentials[:rackspace_flavor_id].to_s ||= Fog::Mock.random_numbers(1)
-            image_id  = Fog.credentials[:rackspace_image_id] ||= Fog::Rackspace::MockData.uuid
+            flavor_id  = Fog.credentials[:rackspace_flavor_id].to_s ||= Fog::Mock.random_numbers(1)
+            image_id   = Fog.credentials[:rackspace_image_id] ||= Fog::Rackspace::MockData.uuid
             image_name = Fog::Mock.random_letters(6)
             network_id = Fog::Rackspace::MockData.uuid
+            user_id    =  Fog::Mock.random_numbers(6).to_s
 
             flavor = {
               "OS-FLV-EXT-DATA:ephemeral" => 4,
@@ -88,6 +89,14 @@ module Fog
               'cidr' => '192.168.0.0/24'
             }
 
+            key_pair = {
+                'public_key'  => "ssh-rsa ".concat(Fog::Mock.random_letters(372)).concat(" Generated by Nova\n"),
+                'private_key' => "-----BEGIN RSA PRIVATE KEY-----\n".concat(Fog::Mock.random_letters(1635)).concat("\n-----END RSA PRIVATE KEY-----\n"),
+                'user_id'     => user_id,
+                'name'        => Fog::Mock.random_letters(32),
+                'fingerprint' => "00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00"
+            }
+
             #Block Storage
             volume_type1_id = Fog::Mock.random_numbers(3).to_s
             volume_type2_id = Fog::Mock.random_numbers(3).to_s
@@ -106,11 +115,13 @@ module Fog
 
             mock_data = {
               #Compute V2
-              :flavors => Hash.new { |h,k| h[k] = flavor unless k == NOT_FOUND_ID},
-              :images => Hash.new { |h,k| h[k] = image unless k == NOT_FOUND_ID },        
+              :flavors  => Hash.new { |h,k| h[k] = flavor  unless k == NOT_FOUND_ID },
+              :images   => Hash.new { |h,k| h[k] = image   unless k == NOT_FOUND_ID },        
               :networks => Hash.new { |h,k| h[k] = network unless k == NOT_FOUND_ID },
-
-              :servers => {},
+              :keys     => [],
+              :keypair  => key_pair,
+              :keypairs => [],
+              :servers  => {},
 
               #Block Storage
               :volumes            => {},
@@ -123,7 +134,7 @@ module Fog
             mock_data[:flavors][flavor_id] = flavor
             mock_data[:images][image_id] = image
             mock_data[:networks][network_id] = network
-            
+
             mock_data
           end
         end[@rackspace_api_key]

data/lib/fog/rackspace/models/compute_v2/key_pair.rb

@@ -0,0 +1,56 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class RackspaceV2
+      class KeyPair < Fog::Model
+
+        # @!attribute [rw] name
+        # @return [String] the keypair name
+        identity  :name
+
+        # @!attribute [r]  public_key
+        # @return [String] the public key
+        attribute :public_key
+
+        # @!attribute [r]  private_key
+        # @return [String] the private key
+        attribute :private_key
+
+        # @!attribute [r]  user_id
+        # @return [String] the user_id associated to
+        attribute :user_id
+
+        # @!attribute [r]  fingerprint
+        # @return [String] unique fingerprint
+        attribute :fingerprint
+
+        # Creates a keypair
+        # @return [Boolean] true if the keypair is successfully created
+        # @raise  [Fog::Compute::RackspaceV2::NotFound]
+        # @raise  [Fog::Compute::RackspaceV2::BadRequest]
+        # @raise  [Fog::Compute::RackspaceV2::InternalServerError]
+        # @raise  [Fog::Compute::RackspaceV2::ServiceError]
+        def save
+          requires :name
+          data = service.create_keypair(name, public_key)
+          merge_attributes(data.body['keypair'])
+          data.body['keypair']['name'] == name
+        end
+
+        # Destroys a keypair
+        # @return [Boolean] true if the keypair is successfully deleted
+        # @raise  [Fog::Compute::RackspaceV2::NotFound]
+        # @raise  [Fog::Compute::RackspaceV2::BadRequest]
+        # @raise  [Fog::Compute::RackspaceV2::InternalServerError]
+        # @raise  [Fog::Compute::RackspaceV2::ServiceError]
+        def destroy
+            requires :identity
+            service.delete_keypair(identity)
+            true
+        end
+
+      end
+    end
+  end
+end