fog 1.9.0 → 1.10.0

data/lib/fog/rackspace/requests/compute_v2/revert_resize_server.rb

@@ -2,6 +2,16 @@ module Fog
   module Compute
     class RackspaceV2
       class Real
+        
+        # Reverts server resize operation
+        # @param [String] server_id
+        # @note All resizes are automatically confirmed after 24 hours if you do not explicitly confirm or revert the resize.        
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/Revert_Resized_Server-d1e4024.html
+        # @see #resize                
+        #
+        # * Status Transition:
+        #   * VERIFY_RESIZE -> ACTIVE
+        #   * VERIFY_RESIZE -> ERROR (on error)        
         def revert_resize_server(server_id)
           data = {
             'revertResize' => nil

data/lib/fog/rackspace/requests/compute_v2/set_metadata.rb

@@ -2,6 +2,15 @@ module Fog
   module Compute
     class RackspaceV2
       class Real
+        
+        # Sets metadata associated with a server or an image.
+        # @param [String<images, servers>] collection type of metadata
+        # @param [String] obj_id id of the object where the metadata is attached
+        # @param [Hash] metadata key value pairs of metadata
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * metadata [Hash]:
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/Create_or_Replace_Metadata-d1e5358.html      
         def set_metadata(collection, obj_id, metadata = {})
           request(
             :expects => [200, 203],

data/lib/fog/rackspace/requests/compute_v2/set_metadata_item.rb

@@ -2,6 +2,16 @@ module Fog
   module Compute
     class RackspaceV2
       class Real
+        
+        # Sets a single metadatum item by key.
+        # @param [String<images, servers>] collection type of metadata
+        # @param [String] obj_id id of the object where the metadata is attached
+        # @param [String] key the key of the metadata to set
+        # @param [String] value the value of the metadata to set        
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * meta [Hash]:
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/Create_or_Update_a_Metadata_Item-d1e5633.html       
         def set_metadata_item(collection, obj_id, key, value)
           request(
             :expects => 200,

data/lib/fog/rackspace/requests/compute_v2/update_metadata.rb

@@ -2,6 +2,15 @@ module Fog
   module Compute
     class RackspaceV2
       class Real
+        
+        # Updates metadata items for a specified server or image.
+        # @param [String<images, servers>] collection type of metadata
+        # @param [String] obj_id id of the object where the metadata is attached
+        # @param [Hash] metadata key value pairs of metadata
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * metadata [Hash]:
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/Update_Metadata-d1e5208.html              
         def update_metadata(collection, obj_id, metadata = {})
           request(
             :expects => [200, 203],

data/lib/fog/rackspace/requests/compute_v2/update_server.rb

@@ -2,6 +2,15 @@ module Fog
   module Compute
     class RackspaceV2
       class Real
+        
+        # Update the editable attributes of a specified server.
+        # @param [String] server_id
+        # @param [Hash] options
+        # @option options [Hash] name name for server
+        # @option options [String] accessIPv4 The IP version 4 address.
+        # @option options [Hash] accessIPv6 The IP version 6 address.
+        # @note If you edit the server name, the server host name does not change. Also, server names are not guaranteed to be unique.
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/ServerUpdate.html  
         def update_server(server_id, options={})
           data = options.is_a?(Hash) ? options : { 'name' => options } #LEGACY - second parameter was previously server name
 

data/lib/fog/rackspace/requests/storage/get_object.rb

@@ -17,7 +17,6 @@ module Fog
           end
 
           request(params.merge!({
-            :block    => block,
             :expects  => 200,
             :method   => 'GET',
             :path     => "#{Fog::Rackspace.escape(container)}/#{Fog::Rackspace.escape(object)}"

data/lib/fog/rackspace/requests/storage/put_container.rb

@@ -8,10 +8,11 @@ module Fog
         # ==== Parameters
         # * name<~String> - Name for container, should be < 256 bytes and must not contain '/'
         #
-        def put_container(name)
+        def put_container(name, options={})
           request(
             :expects  => [201, 202],
             :method   => 'PUT',
+            :headers => options,
             :path     => Fog::Rackspace.escape(name)
           )
         end

data/lib/fog/rackspace/storage.rb

@@ -14,6 +14,7 @@ module Fog
       collection  :directories
       model       :file
       collection  :files
+      model       :account
 
       request_path 'fog/rackspace/requests/storage'
       request :copy_object
@@ -38,7 +39,8 @@ module Fog
             :provider           => 'Rackspace',
             :rackspace_api_key  => @rackspace_api_key,
             :rackspace_auth_url => @rackspace_auth_url,
-            :rackspace_username => @rackspace_username
+            :rackspace_username => @rackspace_username,
+            :rackspace_cdn_ssl => @rackspace_cdn_ssl
           )
           if @cdn.enabled?
             @cdn
@@ -94,9 +96,18 @@ module Fog
           @connection_options     = options[:connection_options] || {}
           authenticate
           @persistent = options[:persistent] || false
-          Excon.ssl_verify_peer = false if options[:rackspace_servicenet] == true
+          Excon.defaults[:ssl_verify_peer] = false if options[:rackspace_servicenet] == true
           @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
         end
+        
+        def account
+          account = Fog::Storage::Rackspace::Account.new(:service => self)
+          account.reload
+        end
+
+        def ssl?
+          !rackspace_cdn_ssl.nil?
+        end
 
         def reload
           @connection.reset
@@ -107,6 +118,7 @@ module Fog
             response = @connection.request(params.merge({
               :headers  => {
                 'Content-Type' => 'application/json',
+                'Accept' => 'application/json',
                 'X-Auth-Token' => @auth_token
               }.merge!(params[:headers] || {}),
               :host     => @host,

data/lib/fog/schema/data_validator.rb

@@ -0,0 +1,154 @@
+module Fog
+  module Schema
+    # This validates a data object against a Ruby based schema to see
+    # if they match.
+    #
+    # * An object matches the schema if +==+ or +===+ returns +true+
+    # * Hashes match if all the key's values match the classes given
+    #   in the schema as well. This can be configured in the options
+    # * Arrays match when every element in the data matches the case
+    #   given in the schema.
+    #
+    # The schema and validation are very simple and probably not
+    # suitable for some cases.
+    #
+    # The following classes can be used to check for special behaviour
+    #
+    # * Fog::Boolean - value may be +true+ or +false+
+    # * Fog::Nullable::Boolean - value may be +true+, +false+ or +nil+
+    # * Fog::Nullable::Integer - value may be an Integer or +nil+
+    # * Fog::Nullable::String
+    # * Fog::Nullable::Time
+    # * Fog::Nullable::Float
+    # * Fog::Nullable::Hash
+    # * Fog::Nullable::Array
+    #
+    # All the "nullable" objects will pass if the value is of the class
+    # or if it is +nil+. This allows you to match APIs that may include
+    # keys when the value is not available in some cases but will
+    # always be a String. Such as an password that is only displayed
+    # on the reset action.
+    #
+    # The keys for "nullable" resources should always be present but
+    # original matcher had a bug that allowed these to also appear to
+    # work as optional keys/values.
+    #
+    # If you need the original behaviour, data with a missing key is
+    # still valid, then you may pass the +:allow_optional_rules+
+    # option to the #validate method.
+    #
+    # That is not recommended because you are describing a schema
+    # with optional keys in a format that does not support it.
+    #
+    # Setting +:allow_extra_keys+ as +true+ allows the data to
+    # contain keys not declared by the schema and still pass. This
+    # is useful if new attributes appear in the API in a backwards
+    # compatible manner and can be ignored.
+    #
+    # This is the behaviour you would have seen with +strict+ being
+    # +false+ in the original test helper.
+    #
+    # @example Schema example
+    #     {
+    #       "id" => String,
+    #       "ram" => Integer,
+    #       "disks" => [
+    #         "size" => Float
+    #       ],
+    #       "dns_name" => Fog::Nullable::String,
+    #       "active" => Fog::Boolean,
+    #       "created" => DateTime
+    #     }
+    #
+    class DataValidator
+
+      def initialize
+        @message = nil
+      end
+
+      # Checks if the data structure matches the schema passed in and
+      # returns +true+ if it fits.
+      #
+      # @param [Object] data Hash or Array to check
+      # @param [Object] schema Schema pattern to check against
+      # @param [Boolean] options
+      # @option options [Boolean] :allow_extra_keys
+      #     If +true+ does not fail if extra keys are in the data
+      #     that are not in the schema.
+      # @option options [Boolean] :allow_optional_rules
+      #     If +true+ does not fail if extra keys are in the schema
+      #     that do not match the data. Not recommended!
+      #
+      # @return [Boolean] Did the data fit the schema?
+      def validate(data, schema, options = {})
+        valid = validate_value(schema, data, options)
+
+        unless valid
+          @message = "#{data.inspect} does not match #{schema.inspect}"
+        end
+        valid
+      end
+
+      # This returns the last message set by the validator
+      #
+      # @return [String]
+      def message
+        @message
+      end
+
+    private
+
+      # This contains a slightly modified version of the Hashidator gem
+      # but unfortunately the gem does not cope with Array schemas.
+      #
+      # @see https://github.com/vangberg/hashidator/blob/master/lib/hashidator.rb
+      #
+      def validate_value(validator, value, options)
+        Fog::Logger.write :debug, "[yellow][DEBUG] #{value.inspect} against #{validator.inspect}[/]\n"
+
+        case validator
+        when Array
+          return false if value.is_a?(Hash)
+          value.respond_to?(:all?) && value.all? {|x| validate_value(validator[0], x, options)}
+        when Symbol
+          value.respond_to? validator
+        when Hash
+          return false if value.is_a?(Array)
+
+          # When being strict values not specified in the schema are fails
+          unless options[:allow_extra_keys]
+            if value.respond_to?(:empty?)
+              # Validator is empty but values are not
+              return false if !value.empty? && validator.empty?
+            end
+          end
+
+          unless options[:allow_optional_rules]
+            if value.respond_to?(:empty?)
+              # Validator has rules left but no more values
+              return false if value.empty? && !validator.empty?
+            end
+          end
+
+          validator.all? do |key, sub_validator|
+            Fog::Logger.write :debug, "[blue][DEBUG] #{key.inspect} against #{sub_validator.inspect}[/]\n"
+            validate_value(sub_validator, value[key], options)
+          end
+        else
+          result = validator == value
+          result = validator === value unless result
+          # Repeat unless we have a Boolean already
+          unless (result.is_a?(TrueClass) || result.is_a?(FalseClass))
+            result = validate_value(result, value, options)
+          end
+          if result
+            Fog::Logger.write :debug, "[green][DEBUG] Validation passed: #{value.inspect} against #{validator.inspect}[/]\n"
+          else
+            Fog::Logger.write :debug, "[red][DEBUG] Validation failed: #{value.inspect} against #{validator.inspect}[/]\n"
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/fog/storage.rb

@@ -8,31 +8,15 @@ module Fog
     def self.new(attributes)
       attributes = attributes.dup # prevent delete from having side effects
       case provider = attributes.delete(:provider).to_s.downcase.to_sym
-      when :atmos
-        require 'fog/atmos/storage'
-        Fog::Storage::Atmos.new(attributes)
-      when :aws
-        require 'fog/aws/storage'
-        Fog::Storage::AWS.new(attributes)
-      when :google
-        require 'fog/google/storage'
-        Fog::Storage::Google.new(attributes)
-      when :hp
-        require 'fog/hp/storage'
-        Fog::Storage::HP.new(attributes)
-      when :ibm
-        require 'fog/ibm/storage'
-        Fog::Storage::IBM.new(attributes)
-      when :local
-        require 'fog/local/storage'
-        Fog::Storage::Local.new(attributes)
-      when :ninefold
-        require 'fog/ninefold/storage'
-        Fog::Storage::Ninefold.new(attributes)
-      when :rackspace
-        require 'fog/rackspace/storage'
-        Fog::Storage::Rackspace.new(attributes)
+      when :internetarchive
+        require 'fog/internet_archive/storage'
+        Fog::Storage::InternetArchive.new(attributes)
       else
+        if self.providers.include?(provider)
+          require "fog/#{provider}/storage"
+          return Fog::Storage.const_get(Fog.providers[provider]).new(attributes)
+        end
+
         raise ArgumentError.new("#{provider} is not a recognized storage provider")
       end
     end

data/lib/fog/terremark/models/shared/server.rb

@@ -41,6 +41,8 @@ module Fog
               data = service.power_off(self.id).body
               wait_for { off? }
             end
+            #Failsafe .. Always check if we are ready
+          wait_for { ready? }
           service.delete_vapp(self.id)
           true
         end
@@ -60,13 +62,13 @@ module Fog
         def delete_internet_services
             #Find the internet service
 
-            while (service = internet_services.pop) do
+            while (inet_service = internet_services.pop) do
 
-              nodes = service.nodeservices.all(service.Id)
+              nodes = service.nodeservices.all(inet_service.Id)
               #Delete all the associated nodes
               nodes.select { |item| item.destroy }
               #Clear out the services
-              service.destroy(delete_public_ip = !(internet_services.size > 0))
+              inet_service.destroy(delete_public_ip = !(internet_services.size > 0))
             end
             true
         end

data/lib/fog/terremark/parser.rb

@@ -1,19 +1,20 @@
-module Fog
-  module Terremark
-    module Shared
-      module Parser
 
-        remove_method :parse
-        def parse(data)
-          case data['type']
-          when 'application/vnd.vmware.vcloud.vApp+xml'
-            servers.new(data.merge!(:service => self))
-          else
-            data
-          end
-        end
+class TerremarkParser < Fog::Parsers::Base
 
+  def extract_attributes(attributes_xml)
+    attributes = {}
+    until attributes_xml.empty?
+      if attributes_xml.first.is_a?(Array)
+        until attributes_xml.first.empty?
+          attribute = attributes_xml.first.shift
+          attributes[attribute.localname] = attribute.value
+        end
+      else
+        attribute = attributes_xml.shift
+        attributes[attribute.localname] = attribute.value
       end
     end
+    attributes
   end
 end
+

data/lib/fog/terremark/parsers/shared/get_catalog.rb

@@ -3,7 +3,7 @@ module Fog
     module Terremark
       module Shared
 
-        class GetCatalog < Fog::Parsers::Base
+        class GetCatalog < TerremarkParser
 
           def reset
             @response = { 'CatalogItems' => [] }
@@ -13,26 +13,12 @@ module Fog
             super
             case name
             when 'CatalogItem'
-              catalog_item = {}
-              attributes.each do |attrib|
-                i = 0
-                while i < attrib.size
-                  catalog_item[attrib[i]] = attrib[i+1]
-                  i += 2
-                end
-                catalog_item["id"] = catalog_item["href"].split('/').last
-              end            
+              catalog_item = extract_attributes(attributes)
+              catalog_item["id"] = catalog_item["href"].split('/').last
               @response['CatalogItems'] << catalog_item
+
             when 'Catalog'
-              catalog = {}
-              until attributes.empty?
-                if attributes.first.is_a?(Array)
-                  attribute = attributes.shift
-                  catalog[attribute.first] = attribute.last
-                else
-                  catalog[attributes.shift] = attributes.shift
-                end
-              end
+              catalog = extract_attributes(attributes)
               @response['name'] = catalog['name']
             end
           end