gapinc-fog 1.12.1.2.1 → 1.14.0

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

@@ -0,0 +1,43 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/compute_v2/key_pair'
+
+module Fog
+  module Compute
+    class RackspaceV2
+
+      class KeyPairs < Fog::Collection
+
+        model Fog::Compute::RackspaceV2::KeyPair
+
+        # Fetch the list of known keypairs
+        # @return [Fog::Compute::RackspaceV2::Keypairs] the retreived keypairs
+        # @raise  [Fog::Compute::RackspaceV2::NotFound]
+        # @raise  [Fog::Compute::RackspaceV2::BadRequest]
+        # @raise  [Fog::Compute::RackspaceV2::InternalServerError]
+        # @raise  [Fog::Compute::RackspaceV2::ServiceError]
+        def all
+          data = []
+          service.list_keypairs.body['keypairs'].each do |kp|
+            data << kp['keypair'] if kp['keypair']
+          end
+          load(data)
+        end
+
+        # Fetch keypair details
+        # @param  [String] key_name: name of the key to request
+        # @return [Fog::Compute::RackspaceV2::Keypair] the requested keypair or 'nil' when not found
+        # @raise  [Fog::Compute::RackspaceV2::BadRequest]
+        # @raise  [Fog::Compute::RackspaceV2::InternalServerError]
+        # @raise  [Fog::Compute::RackspaceV2::ServiceError]
+        def get(key_name)
+            begin
+                new(service.get_keypair(key_name).body['keypair'])
+            rescue Fog::Compute::RackspaceV2::NotFound
+                nil
+            end
+        end
+
+      end
+    end
+  end
+end

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

@@ -51,6 +51,11 @@ module Fog
         # @return [String] server status. 
         # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/List_Servers-d1e2078.html#server_status
         attribute :state, :aliases => 'status'
+
+        # @!attribute [r] state_ext
+        # @return [String] server (extended) status. 
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/List_Servers-d1e2078.html#server_status
+        attribute :state_ext, :aliases => 'OS-EXT-STS:task_state'
                 
         # @!attribute [r] progress
         # @return [Fixnum] The build completion progress, as a percentage. Value is from 0 to 100.
@@ -198,11 +203,11 @@ module Fog
           options[:disk_config] = disk_config unless disk_config.nil?
           options[:metadata] = metadata.to_hash unless @metadata.nil?
           options[:personality] = personality unless personality.nil?
+          options[:keypair] ||= attributes[:keypair]
 
           if options[:networks]
             options[:networks].map! { |id| { :uuid => id } }
           end
-
           data = service.create_server(name, image_id, flavor_id, 1, 1, options)
           merge_attributes(data.body['server'])
           true
@@ -331,7 +336,7 @@ module Fog
         # Server's private IPv4 address
         # @return [String] private IPv4 address
         def private_ip_address
-          addresses['private'].select{|a| a["version"] == 4}[0]["addr"]
+          addresses['private'].select{|a| a["version"] == 4}[0]["addr"] rescue ''
         end
 
         # Server's public IPv4 address

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

@@ -16,8 +16,9 @@ module Fog
         # @raise [Fog::Compute::RackspaceV2::InternalServerError] - HTTP 500
         # @raise [Fog::Compute::RackspaceV2::ServiceError]
         # @note Fog's current implementation only returns 1000 servers
+        # @note The filter parameter on the method is just to maintain compatability with other providers that support filtering.
         # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/List_Servers-d1e2078.html
-        def all
+        def all(filters = {})
           data = service.list_servers.body['servers']
           load(data)
         end

data/lib/fog/rackspace/models/identity/service_catalog.rb

@@ -22,7 +22,7 @@ module Fog
         
         def display_service_regions(service_type)
           endpoints = get_endpoints(service_type)
-          endpoints.collect { |k,v| ":#{k}" }.join(", ")          
+          endpoints.collect { |k,v| ":#{k}" }.join(", ")
         end
         
         def get_endpoint(service_type, region=nil)
@@ -32,7 +32,7 @@ module Fog
           return endpoint if endpoint.is_a?(String) #There is only one endpoint for service
 
           unless region
-            raise "There are multiple endpoints avaliable for #{service_type}. Please specify one of the following regions: #{display_service_regions(service_type)}."
+            raise "There are multiple endpoints available for #{service_type}. Please specify one of the following regions: #{display_service_regions(service_type)}."
           end
           region = region.is_a?(String) ? region.to_sym : region
           endpoint = get_endpoints(service_type)[region]
@@ -48,10 +48,16 @@ module Fog
                 
         def self.from_response(service, hash)
           service_catalog = ServiceCatalog.new :service => service
-          services = hash["access"]["serviceCatalog"]
-          services.each do |serv|
-            name = serv["name"].to_sym
-            service_catalog.send(:add_endpoints, name, serv)
+          begin
+            services = hash["access"]["serviceCatalog"]
+            services.each do |serv|
+              name = serv["name"] ? serv["name"].to_sym : nil
+              next unless name
+              service_catalog.send(:add_endpoints, name, serv)
+            end
+          rescue => e
+            Logger.warning "Exception occurred while loading service catalog - #{e.inspect}"
+            Logger.warning "Unable to load service catalog. Please specify endpoints manually"
           end
           service_catalog
         end
@@ -59,20 +65,32 @@ module Fog
         private
         
         def add_endpoints(service_name, hash)
-          endpoints = hash["endpoints"]
-          if endpoints.size == 1
-            catalog[service_name] = endpoints[0]["publicURL"].freeze
-          else
-            catalog[service_name] = endpoints_from_array(endpoints)
+          begin
+            endpoints = hash["endpoints"]
+            if endpoints.size == 1
+              catalog[service_name] = endpoints[0]["publicURL"].freeze
+            else
+              catalog[service_name] = endpoints_from_array(service_name, endpoints)
+            end
+          rescue => e
+            Logger.warning "Exception occurred while loading #{service_name} service endpoints - #{e.inspect}"
+            Logger.warning "Unable to load service endpoints for #{service_name}. Please specify #{service_name} endpoints manually."
           end
         end
         
-        def endpoints_from_array(endpoints)
+        def endpoints_from_array(service_name, endpoints)
           hash = {}
           endpoints.each do |endpoint|
-            region = endpoint["region"].downcase.to_sym
-            url = endpoint["publicURL"].freeze
-            hash[region] = url
+            begin
+              region_name = endpoint["region"]
+              region = region_name ? region_name.downcase.to_sym : :global
+              url = endpoint["publicURL"].freeze
+              hash[region] = url
+            rescue => e
+              Logger.warning "Exception occurred while loading #{service_name} service endpoints - #{e.inspect}"
+              Logger.warning "Unable to parse #{service_name} endpoint - #{endpoint}"
+              Logger.warning "You may need to specify #{service_name} endpoints manually."
+            end
           end
           hash
         end
@@ -80,4 +98,4 @@ module Fog
       end
     end
   end
-end
+end

data/lib/fog/rackspace/models/monitoring/agent_token.rb

@@ -0,0 +1,40 @@
+require 'fog/core/model'
+require 'fog/rackspace/models/monitoring/base'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class AgentToken < Fog::Rackspace::Monitoring::Base
+
+        identity :id
+
+        attribute :label
+        attribute :token
+
+        def params
+          options = {
+            'label'                => label,
+            'token'                => token
+          }
+          options.reject {|key, value| value.nil?}
+        end
+
+        def save
+          if identity
+            raise NotImplementedError.new "Updating Agent Tokens is not currently implemented"
+          else
+            data = service.create_agent_token(params)
+            self.id = data.headers['X-Object-ID']
+          end
+          true
+        end
+
+        def destroy
+          requires :id
+          service.delete_agent_token(id)
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/monitoring/agent_tokens.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/monitoring/agent_token'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class AgentTokens < Fog::Collection
+
+        model Fog::Rackspace::Monitoring::AgentToken
+
+        def all(options={})
+          clear
+          body = service.list_agent_tokens(options).body
+
+          load(body['values'])
+        end
+
+        def get(id)
+          data = service.get_agent_token(id).body
+          new(data)
+        rescue Fog::Rackspace::Monitoring::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/monitoring/alarm.rb

@@ -0,0 +1,51 @@
+require 'fog/core/model'
+require 'fog/rackspace/models/monitoring/base'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class Alarm < Fog::Rackspace::Monitoring::Base
+
+        identity :id
+        attribute :entity
+        attribute :entity_id
+
+        attribute :label
+        attribute :criteria
+        attribute :check_type
+        attribute :check_id
+        attribute :notification_plan_id
+
+        def params(options={})
+          h = {
+            'label'                => label,
+            'criteria'             => criteria,
+            'notification_plan_id' => notification_plan_id,
+          }.merge(options)
+          h.reject {|key, value| value.nil?}
+        end
+
+        def save
+          requires :notification_plan_id
+          requires :entity_id
+
+          if identity
+            data = service.update_alarm(entity_id, identity, params)
+          else
+            options = params('check_type' => check_type, 'check_id' => check_id)
+            data = service.create_alarm(entity_id, options)
+            self.id = data.headers['X-Object-ID']
+          end
+          true
+        end
+
+        def destroy
+          requires :id
+          service.delete_alarm(entity.id,id)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/rackspace/models/monitoring/alarm_example.rb

@@ -0,0 +1,26 @@
+require 'fog/core/model'
+require 'fog/rackspace/models/monitoring/base'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class AlarmExample < Fog::Rackspace::Monitoring::Base
+
+        identity :id
+
+        attribute :label
+        attribute :description
+        attribute :check_type
+        attribute :criteria
+        attribute :fields
+
+
+        attribute :bound_criteria
+
+        def bound?
+          !bound_criteria.nil?
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/monitoring/alarm_examples.rb

@@ -0,0 +1,31 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/monitoring/alarm_example'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class AlarmExamples < Fog::Collection
+
+        model Fog::Rackspace::Monitoring::AlarmExample
+
+        def all
+          data = service.list_alarm_examples.body['values']
+          load(data)
+        end
+
+        def get(alarm_example_id)
+          data = service.get_alarm_example(alarm_example_id).body
+          new(data)
+        rescue Fog::Rackspace::Monitoring::NotFound
+          nil
+        end
+
+        def evaluate(alarm_example_id, options={})
+          data = service.evaluate_alarm_example(alarm_example_id, options).body
+          new(data)
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/monitoring/alarms.rb

@@ -0,0 +1,40 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/monitoring/alarm'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class Alarms < Fog::Collection
+
+        attribute :entity
+
+        model Fog::Rackspace::Monitoring::Alarm
+
+        def all
+          requires :entity
+          data = service.list_alarms(entity.identity).body['values']
+          load(data)
+        end
+
+        def get(alarm_id)
+          requires :entity
+          data = service.get_alarm(entity.identity, alarm_id).body
+          new(data)
+        rescue Fog::Rackspace::Monitoring::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :entity
+          super({ :entity => entity }.merge!(attributes))
+        end
+
+        def create(attributes = {})
+          requires :entity
+          super({ :entity => entity }.merge!(attributes))
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/monitoring/base.rb

@@ -0,0 +1,36 @@
+require 'digest/md5'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class Base < Fog::Model
+
+        attribute :created_at
+        attribute :updated_at
+
+        # Back to drawing board on this one I think
+        def hash
+          attrs = attributes.dup
+          attrs.delete_if {|key, value| [:created_at, :updated_at, :id].include?(key)}
+          attrs.delete_if {|key, value| value.kind_of?(Base) }
+          keys = attrs.keys.map{|sym| sym.to_s}.sort.join ''
+          values = attrs.values.map{|sym| sym.to_s}.sort.join ''
+          Digest::MD5.hexdigest(keys + values)
+        end
+
+        def compare?(b)
+          a_o = params
+          b_o = b.params
+          remain = a_o.reject {|key, value| b_o[key] === value}
+          remain.empty?
+        end
+
+        def entity_id
+          raise(ArgumentError, "entity with id is required for this operation") unless entity && entity.identity
+          entity.identity
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/monitoring/check.rb

@@ -0,0 +1,75 @@
+require 'fog/core/model'
+require 'fog/rackspace/models/monitoring/base'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class Check < Fog::Rackspace::Monitoring::Base
+
+        identity :id
+        attribute :entity
+
+        attribute :label
+        attribute :metadata
+        attribute :target_alias
+        attribute :target_resolver
+        attribute :target_hostname
+        attribute :period
+        attribute :timeout
+        attribute :type
+        attribute :details
+        attribute :disabled
+        attribute :monitoring_zones_poll
+
+        def entity=(obj)
+           attributes[:entity] = obj.is_a?(String) ? Entity.new(:id => obj) : obj
+         end
+
+        def params(options={})
+          h = {
+            'label'       => label,
+            'metadata'    => metadata,
+            'target_alias'=> target_alias,
+            'target_resolver' => target_resolver,
+            'target_hostname' => target_hostname,
+            'period' => period,
+            'timeout'=> timeout,
+            'details'=> details,
+            'monitoring_zones_poll'=> monitoring_zones_poll,
+            'disabled'=> disabled
+          }.merge(options)
+
+          h.reject {|key, value| value.nil?}
+        end
+
+        def save
+          if identity
+            data = service.update_check(entity.id, identity, params)
+          else
+            requires :type
+            options = params('type' => type)
+            data = service.create_check(entity.id, options)
+            self.id = data.headers['X-Object-ID']
+          end
+          true
+        end
+
+        def destroy
+          requires :id
+          service.delete_check(entity.id, id)
+        end
+
+        def metrics
+          @metrics ||= begin
+            Fog::Rackspace::Monitoring::Metrics.new(
+              :check      => self,
+              :service => service
+            )
+          end
+        end
+
+      end
+
+    end
+  end
+end