gapinc-fog 1.12.1.2.1 → 1.14.0

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

@@ -0,0 +1,15 @@
+require 'fog/core/model'
+require 'fog/rackspace/models/monitoring/base'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class CheckType < Fog::Rackspace::Monitoring::Base
+        identity :id
+        attribute :type
+        attribute :fields
+        attribute :channel
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/monitoring/check_type'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class CheckTypes < Fog::Collection
+
+        model Fog::Rackspace::Monitoring::CheckType
+
+        def all
+          data = service.list_check_types.body['values']
+          load(data)
+        end
+
+        def new(attributes = {})
+          super({ }.merge!(attributes))
+        end
+
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,18 @@
+require 'fog/core/model'
+require 'fog/rackspace/models/monitoring/base'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class DataPoint < Fog::Rackspace::Monitoring::Base
+        attribute :num_points, :aliases => "numPoints"
+        attribute :average
+        attribute :variance
+        attribute :min
+        attribute :max
+        attribute :timestamp
+        attribute :metric
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/monitoring/data_point'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class DataPoints < Fog::Collection
+
+        attribute :metric
+
+        model Fog::Rackspace::Monitoring::DataPoint
+
+        def all
+          self.fetch(:resolution => :full)
+        end
+
+        # Fetch the datapoints for a metric
+        # ==== Parameters
+        #
+        # * options<~Hash> - optional paramaters
+        #   * from<~Integer> - timestamp in milliseconds
+        #   * to<~Integer> - timestamp in milliseconds
+        #   * points<~Integer> - Number of points to fetch
+        #   * resolution<~String> - Should be one of :full, :min5, :min20, :min60, :min240, :min1440
+        #   * select<~Array> - Should be an array of :average, :max, :min, :variance
+        #
+        # ==== Returns
+        # * datapoints<~Fog::Rackspace::Monitoring::Datapoints>:
+        def fetch(options={})
+          requires :metric
+          options[:from] ||= (Time.now.to_i * 1000) - (3600 * 1000)
+          options[:to] ||= Time.now.to_i * 1000
+          options[:points] ||= 1 unless options[:resolution]
+          if options[:resolution]
+            options[:resolution] = options[:resolution].upcase
+          end
+          data = service.list_data_points(metric.check.entity.id, metric.check.id, metric.name, options).body['values']
+          load(data)
+        end
+
+        def new(attributes = {})
+          requires :metric
+          super({ :metric => metric }.merge!(attributes))
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/monitoring/entity'
+require 'fog/rackspace/models/monitoring/check'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class Entities < Fog::Collection
+
+        model Fog::Rackspace::Monitoring::Entity
+
+        attribute :marker
+
+        def all(options={})
+          data = service.list_entities(options).body
+          marker = data['metadata']['next_marker']
+
+          load(data['values'])
+        end
+
+        def get(entity_id)
+          data = service.get_entity(entity_id).body
+          new(data)
+        rescue Fog::Rackspace::Monitoring::NotFound
+          nil
+        end
+
+        def overview(options={})
+          body = service.list_overview(options).body
+          marker = body['metadata']['next_marker']
+
+          load_all(body['values'])
+        end
+
+        def load_all(objects)
+          clear
+          for object in objects
+            en = new(object['entity'])
+            self << en
+            en.checks.load(object['checks'])
+            en.alarms.load(object['alarms'])
+          end
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'fog/core/model'
+require 'fog/rackspace/models/monitoring/base'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class Entity < Fog::Rackspace::Monitoring::Base
+
+        identity :id
+
+        attribute :label
+        attribute :metadata
+        attribute :ip_addresses
+        attribute :agent_id
+        attribute :managed, :default => false
+        attribute :uri
+
+        def params
+          options = {
+            'label'       => label,
+            'metadata'    => metadata,
+            'ip_addresses'=> ip_addresses,
+            'agent_id'    => agent_id
+          }
+          options.reject {|key, value| value.nil?}
+        end
+
+        def save
+          if identity
+            data = service.update_entity(identity, params)
+          else
+            data = service.create_entity(params)
+            self.id = data.headers['X-Object-ID']
+          end
+          true
+        end
+
+        def checks
+          @checks ||= begin
+            Fog::Rackspace::Monitoring::Checks.new(
+              :entity     => self,
+              :service => service
+            )
+          end
+        end
+
+        def alarms
+          @alarms ||= begin
+            Fog::Rackspace::Monitoring::Alarms.new(
+              :entity     => self,
+              :service => service
+            )
+          end
+        end
+
+        def destroy
+          requires :id
+          service.delete_entity(id)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'fog/core/model'
+require 'fog/rackspace/models/monitoring/base'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class Metric < Fog::Rackspace::Monitoring::Base
+
+        identity  :name
+        attribute :check
+
+        def datapoints(options={})
+          @datapoints ||= begin
+            Fog::Rackspace::Monitoring::DataPoints.new(
+              :metric        => self,
+              :service       => service
+            )
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/monitoring/metric'
+
+module Fog
+  module Rackspace
+    class Monitoring
+      class Metrics < Fog::Collection
+
+        attribute :check
+
+        model Fog::Rackspace::Monitoring::Metric
+
+        def all
+          requires :check
+          data = service.list_metrics(check.entity.id, check.id).body['values']
+          load(data)
+        end
+
+        def new(attributes = {})
+          requires :check
+          super({ :check => check }.merge!(attributes))
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/rackspace/monitoring.rb

@@ -0,0 +1,149 @@
+# This class originally came from the rackspace-monitoring gem located here:
+# https://github.com/racker/rackspace-monitoring-rb
+# It has been heavily modified for import into Fog master.
+
+require 'fog'
+require 'fog/core'
+
+module Fog
+  module Rackspace
+    class Monitoring < Fog::Service
+      include Fog::Rackspace::Errors
+
+      class IdentifierTaken < Fog::Errors::Error; end
+      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
+
+      requires :rackspace_api_key, :rackspace_username
+      recognizes :rackspace_auth_url
+      recognizes :persistent
+      recognizes :rackspace_monitoring_url
+      recognizes :rackspace_region
+
+      model_path  'fog/rackspace/models/monitoring'
+      model       :entity
+      collection  :entities
+      model       :check
+      collection  :checks
+      model       :alarm
+      collection  :alarms
+      model       :alarm_example
+      collection  :alarm_examples
+      model       :agent_token
+      collection  :agent_tokens
+      model       :metric
+      collection  :metrics
+      model       :data_point
+      collection  :data_points
+      model       :check_type
+      collection  :check_types
+
+      request_path 'fog/rackspace/requests/monitoring'
+      request      :list_agent_tokens
+      request      :list_alarms
+      request      :list_alarm_examples
+      request      :list_checks
+      request      :list_entities
+      request      :list_metrics
+      request      :list_data_points
+      request      :list_check_types
+      request      :list_overview
+      request      :list_notification_plans
+
+      request      :get_agent_token
+      request      :get_alarm
+      request      :get_alarm_example
+      request      :get_check
+      request      :get_entity
+
+      request      :create_agent_token
+      request      :create_alarm
+      request      :create_check
+      request      :create_entity
+
+      request      :update_check
+      request      :update_entity
+      request      :update_alarm
+
+      request      :delete_agent_token
+      request      :delete_alarm
+      request      :delete_check
+      request      :delete_entity
+
+      request      :evaluate_alarm_example
+
+
+      class Mock < Fog::Rackspace::Service
+
+        def initialize(options={})
+        end
+
+        def request(params)
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real < Fog::Rackspace::Service
+        def service_name
+          :cloudMonitoring
+        end
+
+        def region
+          @rackspace_region
+        end
+
+        def initialize(options={})
+          @rackspace_api_key = options[:rackspace_api_key]
+          @rackspace_username = options[:rackspace_username]
+          @rackspace_auth_url = options[:rackspace_auth_url]
+          @connection_options = options[:connection_options] || {}
+          @rackspace_endpoint = Fog::Rackspace.normalize_url(options[:rackspace_monitoring_url])
+
+          authenticate
+
+          @persistent = options[:persistent] || false
+          @connection = Fog::Connection.new(endpoint_uri.to_s, @persistent, @connection_options)
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def endpoint_uri(service_endpoint_url=nil)
+          @uri = super(@rackspace_endpoint || service_endpoint_url, :rackspace_monitoring_url)
+        end
+
+        private
+
+        def request(params, parse_json = true, &block)
+          super(params, parse_json, &block)
+          rescue Excon::Errors::BadRequest => error
+            raise BadRequest.slurp error
+          rescue Excon::Errors::Conflict => error
+            raise Conflict.slurp error
+          rescue Excon::Errors::NotFound => error
+            raise NotFound.slurp(error, region)
+          rescue Excon::Errors::ServiceUnavailable => error
+            raise ServiceUnavailable.slurp error
+          rescue Excon::Errors::InternalServerError => error
+            raise InternalServerError.slurp error
+          rescue Excon::Errors::HTTPStatusError => error
+            raise ServiceError.slurp error
+        end
+
+        def authenticate
+          options = {
+            :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
+  end
+end