fog 1.37.0 → 1.38.0

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

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

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

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