fog-maestrodev 1.8.0.20130114204828 → 1.14.0.20130806165225

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

@@ -7,14 +7,39 @@ module Fog
 
       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 = {
@@ -35,6 +60,14 @@ module Fog
           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 :each_file_this_page :each
         def each
           if !block_given?
@@ -52,25 +85,66 @@ module Fog
           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
+            :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
-            "#{self.directory.public_url}/#{Fog::Rackspace.escape(key, '/')}"
+            Files::file_url directory.public_url, key
           end
         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)
@@ -82,13 +156,24 @@ module Fog
           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
 
-      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,152 @@
+require 'fog/rackspace/models/storage/directory'
+require 'fog/rackspace/models/storage/file'
+require 'fog/rackspace/models/storage/directories'
+require 'fog/rackspace/models/storage/files'
+
+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
+        
+        # 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.collect!(&: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(/[-_]/).collect(&:capitalize).join('-')
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/fog/rackspace/monitoring.rb

@@ -0,0 +1,145 @@
+# 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 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

data/lib/fog/rackspace/requests/block_storage/create_snapshot.rb

@@ -2,6 +2,30 @@ module Fog
   module Rackspace
     class BlockStorage
       class Real
+
+        # Create a snapshot from a volume
+        #
+        # @param [String] volume_id Id of server to create image from
+        # @param [Hash] options
+        # @option options [String] :display_name display name for snapshot
+        # @option options [String] :display_description display description for snapshot
+        # @option options [Boolean] :force Set to true to force service to create snapshot
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * 'snapshot' [Hash]:
+        #       * 'volume_id' [String]: - the volume_id of the snapshot
+        #         * 'display_description' [String]: - display description of snapshot
+        #         * 'status' [String]: - status of snapshot
+        #         * 'id' [String]: - id of snapshot
+        #         * 'size' [Fixnum]: - size of the snapshot in GB
+        #         * 'display_name' [String]: - display name of snapshot
+        #         * 'created_at' [String]: - creation time of snapshot
+        # @raise [Fog::Rackspace::BlockStorage::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::BlockStorage::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::BlockStorage::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::BlockStorage::ServiceError]
+        # @note All writes to the volume should be flushed before creating the snapshot, either by un-mounting any file systems on the volume or by detaching the volume.
+        # @see http://docs.rackspace.com/cbs/api/v1.0/cbs-devguide/content/POST_createSnapshot__v1__tenant_id__snapshots.html
         def create_snapshot(volume_id, options = {})
           data = {
             'snapshot' => {
@@ -21,6 +45,34 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def create_snapshot(volume_id, options = {})
+          volume = self.data[:volumes][volume_id]
+          if volume.nil?
+            raise Fog::Rackspace::BlockStorage::NotFound
+          else
+            snapshot_id         = Fog::Rackspace::MockData.uuid
+            display_name        = options[:display_name] || "test snapshot"
+            display_description = options[:display_description] || "test snapshot description"
+
+            snapshot = {
+              "id"                  => snapshot_id,
+              "display_name"        => display_name,
+              "display_description" => display_description,
+              "volume_id"           => volume_id,
+              "status"              => "available",
+              "size"                => volume["size"],
+              "created_at"          => Fog::Rackspace::MockData.zulu_time,
+              "availability_zone"   => "nova",
+            }
+
+            self.data[:snapshots][snapshot_id] = snapshot
+
+            response(:body => {"snapshot" => snapshot})
+          end
+        end
+      end
     end
   end
 end