fog-rackspace 0.1.0

data/lib/fog/rackspace/models/storage/files.rb

@@ -0,0 +1,201 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/storage/file'
+
+module Fog
+  module Storage
+    class Rackspace
+      class Files < Fog::Collection
+        # @!attribute [rw] directory
+        # @return [String] The name of the directory
+        # @note Methods in this class require this attribute to be set
+        attribute :directory
+
+        # @!attribute [rw] limit
+        # @return [Integer] For an integer value n, limits the number of results to at most n values.
+        # @see http://docs.rackspace.com/files/api/v1/cf-devguide/content/List_Large_Number_of_Objects-d1e1521.html
+        attribute :limit
+
+        # @!attribute [rw] marker
+        # @return [String] Given a string value x, return object names greater in value than the specified marker.
+        # @see http://docs.rackspace.com/files/api/v1/cf-devguide/content/List_Large_Number_of_Objects-d1e1521.html
+        attribute :marker
+
+        # @!attribute [rw] path
+        # @return [String] For a string value x, return the object names nested in the pseudo path.
+        # Equivalent to setting delimiter to '/' and prefix to the path with a '/' on the end.
+        attribute :path
+
+        # @!attribute [rw] prefix
+        # @return [String] For a string value x, causes the results to be limited to object names beginning with the substring x.
+        attribute :prefix
+
+        model Fog::Storage::Rackspace::File
+
+        # Returns list of files
+        # @return [Fog::Storage::Rackspace::Files] Retrieves a list files.
+        # @raise [Fog::Storage::Rackspace::NotFound] - HTTP 404
+        # @raise [Fog::Storage::Rackspace::BadRequest] - HTTP 400
+        # @raise [Fog::Storage::Rackspace::InternalServerError] - HTTP 500
+        # @raise [Fog::Storage::Rackspace::ServiceError]
+        # @see http://docs.rackspace.com/files/api/v1/cf-devguide/content/List_Objects-d1e1284.html
+        def all(options = {})
+          requires :directory
+          options = {
+            'limit'   => limit,
+            'marker'  => marker,
+            'path'    => path,
+            'prefix'  => prefix
+          }.merge!(options)
+          merge_attributes(options)
+          parent = directory.collection.get(
+            directory.key,
+            options
+          )
+          if parent
+            load(parent.files.map {|file| file.attributes})
+          else
+            nil
+          end
+        end
+
+        # Calls block for each file in the directory
+        # @yieldparam [Fog::Storage::Rackspace::File]
+        # @return [Fog::Storage::Rackspace::Directory] returns itself
+        # @raise [Fog::Storage::Rackspace::NotFound] - HTTP 404
+        # @raise [Fog::Storage::Rackspace::BadRequest] - HTTP 400
+        # @raise [Fog::Storage::Rackspace::InternalServerError] - HTTP 500
+        # @raise [Fog::Storage::Rackspace::ServiceError]
+        # @note This method retrieves files in pages. Page size is defined by the limit attribute
+        alias_method :each_file_this_page, :each
+        def each
+          if !block_given?
+            self
+          else
+            subset = dup.all
+
+            subset.each_file_this_page {|f| yield f}
+            while subset.length == (subset.limit || 10000)
+              subset = subset.all(:marker => subset.last.key)
+              subset.each_file_this_page {|f| yield f}
+            end
+
+            self
+          end
+        end
+
+        # Retrieves file
+        # @param [String] key of file
+        # @yield get yields to block after chunk of data has been received (Optional)
+        # @yieldparam [String] data
+        # @yieldparam [Integer] remaining
+        # @yieldparam [Integer] content_length
+        # @return [Fog::Storage::Rackspace:File]
+        # @raise [Fog::Storage::Rackspace::NotFound] - HTTP 404
+        # @raise [Fog::Storage::Rackspace::BadRequest] - HTTP 400
+        # @raise [Fog::Storage::Rackspace::InternalServerError] - HTTP 500
+        # @raise [Fog::Storage::Rackspace::ServiceError]
+        # @note If a block is provided, the body attribute will be empty. By default chunk size is 1 MB. This value can be changed by passing the parameter :chunk_size
+        #   into the :connection_options hash in the service constructor.
+        # @example Download an image from Cloud Files and save it to file
+        #
+        #   File.open('download.jpg', 'w') do | f |
+        #     my_directory.files.get("europe.jpg") do |data, remaing, content_length|
+        #       f.syswrite data
+        #     end
+        #   end
+        #
+        # @see http://docs.rackspace.com/files/api/v1/cf-devguide/content/Retrieve_Object-d1e1856.html
+        def get(key, &block)
+          requires :directory
+          data = service.get_object(directory.key, key, &block)
+          metadata = Metadata.from_headers(self, data.headers)
+          file_data = data.headers.merge({
+            :body => data.body,
+            :key  => key,
+            :metadata => metadata
+          })
+
+          new(file_data)
+        rescue Fog::Storage::Rackspace::NotFound
+          nil
+        end
+
+        # Returns the public_url for the given object key
+        # @param key of the object
+        # @return [String] url for object
+        # @raise [Fog::Storage::Rackspace::NotFound] - HTTP 404
+        # @raise [Fog::Storage::Rackspace::BadRequest] - HTTP 400
+        # @raise [Fog::Storage::Rackspace::InternalServerError] - HTTP 500
+        # @raise [Fog::Storage::Rackspace::ServiceError]
+        # @see Directory#public_url
+        def get_url(key)
+          requires :directory
+          if self.directory.public_url
+            Files::file_url directory.public_url, key
+          end
+        end
+
+        # Get a temporary http url for a file.
+        #
+        # required attributes: key
+        # @param key [String] the key of the file within the directory
+        # @param expires [String] number of seconds (since 1970-01-01 00:00) before url expires
+        # @param options [Hash]
+        # @return [String] url
+        # @note This URL does not use the Rackspace CDN
+        def get_http_url(key, expires, options = {})
+          requires :directory
+          service.get_object_http_url(directory.key, key, expires, options)
+        end
+
+        # Get a temporary https url for a file.
+        #
+        # required attributes: key
+        # @param key [String] the key of the file within the directory
+        # @param expires [String] number of seconds (since 1970-01-01 00:00) before url expires
+        # @param options [Hash]
+        # @return [String] url
+        # @note This URL does not use the Rackspace CDN
+        def get_https_url(key, expires, options = {})
+          service.get_object_https_url(directory.key, key, expires, options)
+        end
+
+        # View directory detail without loading file contents
+        # @param key of the object
+        # @param options Required for compatibility with other Fog providers. Not Used.
+        # @return [Fog::Storage::Rackspace::File]
+        # @raise [Fog::Storage::Rackspace::NotFound] - HTTP 404
+        # @raise [Fog::Storage::Rackspace::BadRequest] - HTTP 400
+        # @raise [Fog::Storage::Rackspace::InternalServerError] - HTTP 500
+        # @raise [Fog::Storage::Rackspace::ServiceError]
+        def head(key, options = {})
+          requires :directory
+          data = service.head_object(directory.key, key)
+          file_data = data.headers.merge({
+            :key => key
+          })
+          new(file_data)
+        rescue Fog::Storage::Rackspace::NotFound
+          nil
+        end
+
+        # Create a new file object
+        # @param [Hash] attributes of object
+        # @return [Fog::Storage::Rackspace::File]
+        def new(attributes = {})
+          requires :directory
+          super({ :directory => directory }.merge!(attributes))
+        end
+
+        # Returns an escaped object url
+        # @param [String] path of the url
+        # @param [String] key of the object
+        # @return [String] escaped file url
+        def self.file_url(path, key)
+          return nil unless path
+          "#{path}/#{Fog::Rackspace.escape(key, '/')}"
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/storage/metadata.rb

@@ -0,0 +1,165 @@
+module Fog
+  module Storage
+    class Rackspace
+      class Metadata
+        OBJECT_META_PREFIX = "X-Object-Meta-"
+        OBJECT_REMOVE_META_PREFIX = "X-Remove-Object-Meta-"
+        CONTAINER_META_PREFIX = "X-Container-Meta-"
+        CONTAINER_REMOVE_META_PREFIX = "X-Remove-Container-Meta-"
+
+        # Cloud Files will ignore headers without a value
+        DUMMY_VALUE = 1
+
+        CONTAINER_KEY_REGEX = /^#{CONTAINER_META_PREFIX}(.*)/
+        OBJECT_KEY_REGEX = /^#{OBJECT_META_PREFIX}(.*)/
+
+        # @!attribute [rw] data
+        # @return [Hash] underlying data store for metadata class
+        attr_reader :data
+
+        # @!attribute [rw] parent
+        # @return [Fog::Storage::Rackspace::Directory,Fog::Storage::Rackspace::File] the parent object of the metadata
+        attr_reader :parent
+
+        # Initialize
+        # @param [Fog::Storage::Rackspace::Directory,Fog::Storage::Rackspace::File] parent object of the metadata
+        # @param [Hash] hash containing initial metadata values
+        def initialize(parent, hash={})
+          @data = hash || {}
+          @deleted_hash = {}
+          @parent = parent
+        end
+
+        # Delete key value pair from metadata
+        # @param [String] key to be deleted
+        # @return [Object] returns value for key
+        # @note Metadata must be deleted using this method in order to properly remove it from Cloud Files
+        def delete(key)
+          data.delete(key)
+          @deleted_hash[key] = nil
+        end
+
+        # Returns metadata in a format expected by Cloud Files
+        # @return [Hash] Metadata in a format expected by Cloud Files
+        def to_headers
+          headers = {}
+          h = data.merge(@deleted_hash)
+          h.each_pair do |k,v|
+            key = to_header_key(k,v)
+            headers[key] = v || DUMMY_VALUE
+          end
+
+          headers
+        end
+
+        # Retrieve specific value for key from Metadata.
+        # * If key is of type String, this method will return the value of the metadatum
+        # @param [#key] key
+        # @return [#value]
+        def [](key)
+          return nil unless key
+          @data[key.to_s] || @data[key.to_sym]
+        end
+
+        # Set value for key.
+        # * If key is of type String, this method will set/add the value to Metadata
+        # @param [#key] key
+        # @return [String]
+        def []=(key, value)
+          return nil unless key
+          if @data[key.to_s]
+            @data[key.to_s] = value
+          elsif @data[key.to_sym]
+            @data[key.to_sym] = value
+          else
+            @data[key] = value
+          end
+        end
+
+        # Creates metadata object from Cloud File Headers
+        # @param [Fog::Storage::Rackspace::Directory,Fog::Storage::Rackspace::File] parent object of the metadata
+        # @param [Hash] headers Cloud File headers
+        def self.from_headers(parent, headers)
+          metadata = Metadata.new(parent)
+          headers.each_pair do |k, v|
+            key = metadata.send(:to_key, k)
+            next unless key
+            metadata.data[key] = v
+          end
+          metadata
+        end
+
+        # Returns true if method is implemented by Metadata class
+        # @param [Symbol] method_sym
+        # @param [Boolean] include_private
+        def respond_to?(method_sym, include_private = false)
+          super(method_sym, include_private) || data.respond_to?(method_sym, include_private)
+        end
+
+        # Invoked by Ruby when obj is sent a message it cannot handle.
+        def method_missing(method, *args, &block)
+          data.send(method, *args, &block)
+        end
+
+        private
+
+        def directory?
+          [Fog::Storage::Rackspace::Directory, Fog::Storage::Rackspace::Directories].include? parent_class
+        end
+
+        def file?
+          [Fog::Storage::Rackspace::File, Fog::Storage::Rackspace::Files].include? parent_class
+        end
+
+        def parent_class
+          parent.is_a?(Class) ? parent : parent.class
+        end
+
+        def meta_prefix
+          if directory?
+            CONTAINER_META_PREFIX
+          elsif file?
+            OBJECT_META_PREFIX
+          else
+            raise "Metadata prefix is unknown for #{parent_class}"
+          end
+        end
+
+        def remove_meta_prefix
+          if directory?
+            CONTAINER_REMOVE_META_PREFIX
+          elsif file?
+            OBJECT_REMOVE_META_PREFIX
+          else
+            raise "Remove Metadata prefix is unknown for #{parent_class}"
+          end
+        end
+
+        def meta_prefix_regex
+          if directory?
+            CONTAINER_KEY_REGEX
+          elsif file?
+            OBJECT_KEY_REGEX
+          else
+            raise "Metadata prefix is unknown for #{parent_class}"
+          end
+        end
+
+        def to_key(key)
+           m = key.match meta_prefix_regex
+           return nil unless m && m[1]
+
+           a = m[1].split('-')
+           a.map!(&:downcase)
+           str = a.join('_')
+           str.to_sym
+         end
+
+        def to_header_key(key, value)
+          prefix = value.nil? ?  remove_meta_prefix : meta_prefix
+          prefix + key.to_s.split(/[-_]/).map(&:capitalize).join('-')
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/monitoring.rb

@@ -0,0 +1,184 @@
+require 'fog/rackspace/core'
+# 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.
+
+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 Conflict < Fog::Rackspace::Errors::Conflict; end
+      class ServiceUnavailable < Fog::Rackspace::Errors::ServiceUnavailable; end
+
+      class BadRequest < Fog::Rackspace::Errors::BadRequest
+        attr_reader :validation_errors
+
+        def self.slurp(error, service=nil)
+          new_error = super(error)
+          if  new_error.response_data && new_error.response_data['details']
+            new_error.instance_variable_set(:@validation_errors, new_error.response_data['details'])
+          end
+
+          status_code = error.response ? error.response.status : nil
+          new_error.instance_variable_set(:@status_code, status_code)
+          new_error.set_transaction_id(error, service)
+          new_error
+        end
+      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
+      model       :notification
+      collection  :notifications
+
+      request_path 'fog/rackspace/requests/monitoring'
+      request      :list_agent_tokens
+      request      :list_agents
+      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      :list_notifications
+
+      request      :get_agent
+      request      :get_agent_token
+      request      :get_alarm
+      request      :get_alarm_example
+      request      :get_check
+      request      :get_entity
+      request      :get_notification
+      request      :get_cpus_info
+      request      :get_disks_info
+      request      :get_filesystems_info
+      request      :get_memory_info
+      request      :get_network_interfaces_info
+      request      :get_processes_info
+      request      :get_system_info
+      request      :get_logged_in_user_info
+
+      request      :create_agent_token
+      request      :create_alarm
+      request      :create_check
+      request      :create_entity
+      request      :create_notification
+
+      request      :update_check
+      request      :update_entity
+      request      :update_alarm
+      request      :update_notification
+
+      request      :delete_agent_token
+      request      :delete_alarm
+      request      :delete_check
+      request      :delete_entity
+      request      :delete_notification
+
+      request      :evaluate_alarm_example
+
+      request      :list_monitoring_zones
+      request      :get_monitoring_zone
+
+      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::Core::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
+
+        def request_id_header
+         "X-Response-Id"
+        end
+
+        private
+
+        def request(params, parse_json = true)
+          super
+        rescue Excon::Errors::BadRequest => error
+          raise BadRequest.slurp(error, self)
+        rescue Excon::Errors::Conflict => error
+          raise Conflict.slurp(error, self)
+        rescue Excon::Errors::NotFound => error
+          raise NotFound.slurp(error, self)
+        rescue Excon::Errors::ServiceUnavailable => error
+          raise ServiceUnavailable.slurp(error, self)
+        rescue Excon::Errors::InternalServerError => error
+          raise InternalServerError.slurp(error, self)
+        rescue Excon::Errors::HTTPStatusError => error
+          raise ServiceError.slurp(error, self)
+        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