fog-core 2.1.0 → 2.6.0

data/lib/fog/billing.rb

@@ -1,16 +1,5 @@
 module Fog
   module Billing
     extend Fog::ServicesMixin
-
-    def self.new(orig_attributes)
-      attributes = orig_attributes.dup
-      provider = attributes.delete(:provider).to_s.downcase.to_sym
-      if provider == :stormondemand
-        require "fog/billing/storm_on_demand"
-        Fog::Billing::StormOnDemand.new(attributes)
-      else
-        super(orig_attributes)
-      end
-    end
   end
 end

data/lib/fog/compute/models/server.rb

@@ -53,12 +53,13 @@ module Fog
       def ssh_ip_address
         return public_ip_address unless @ssh_ip_address
         return @ssh_ip_address.call(self) if @ssh_ip_address.is_a?(Proc)
+
         @ssh_ip_address
       end
 
       def ssh_options
         @ssh_options ||= {}
-        ssh_options = @ssh_options.merge(:port => ssh_port)
+        ssh_options = @ssh_options.merge(port: ssh_port)
         if private_key
           ssh_options[:key_data] = [private_key]
           ssh_options[:auth_methods] = %w(publickey)
@@ -89,9 +90,12 @@ module Fog
       end
 
       def sshable?(options = {})
-        result = ready? && !ssh_ip_address.nil? && !!Timeout.timeout(sshable_timeout) { ssh("pwd", options) }
+        return false unless ready? && ssh_ip_address
+
+        Timeout.timeout(sshable_timeout) { ssh("pwd", options) }
         @sshable_timeout = nil
-        result
+
+        true
       rescue SystemCallError
         false
       rescue Net::SSH::AuthenticationFailed, Net::SSH::Disconnect

data/lib/fog/compute.rb

@@ -7,16 +7,6 @@ module Fog
       provider = attributes.delete(:provider).to_s.downcase.to_sym
 
       case provider
-      when :gogrid
-        require "fog/go_grid/compute"
-        Fog::Compute::GoGrid.new(attributes)
-      when :new_servers
-        require "fog/bare_metal_cloud/compute"
-        Fog::Logger.deprecation "`new_servers` is deprecated. Please use `bare_metal_cloud` instead."
-        Fog::Compute::BareMetalCloud.new(attributes)
-      when :baremetalcloud
-        require "fog/bare_metal_cloud/compute"
-        Fog::Compute::BareMetalCloud.new(attributes)
       when :rackspace
         version = attributes.delete(:version)
         version = version.to_s.downcase.to_sym unless version.nil?
@@ -32,26 +22,14 @@ module Fog
         version = attributes.delete(:version)
         version = version.to_s.downcase.to_sym unless version.nil?
         if version == :v1
-          error_message = 'DigitalOcean V1 is deprecated.Please use `:version => :v2` attribute to use Next Gen Cloud Servers.'
+          error_message = "DigitalOcean V1 is deprecated.Please use `:version => :v2` attribute to use Next Gen Cloud Servers."
           raise error_message
         else
-          require 'fog/digitalocean/compute'
+          require "fog/digitalocean/compute"
           Fog::Compute::DigitalOcean.new(attributes)
         end
-      when :stormondemand
-        require "fog/compute/storm_on_demand"
-        Fog::Compute::StormOnDemand.new(attributes)
-      when :vcloud
-        require "fog/vcloud/compute"
-        Fog::Vcloud::Compute.new(attributes)
-      when :vclouddirector
-        require "fog/vcloud_director/compute"
-        Fog::Compute::VcloudDirector.new(attributes)
-      when :cloudatcost
-        require "fog/cloudatcost/compute"
-        Fog::Compute::CloudAtCost.new(attributes)
       else
-        super(orig_attributes)
+        super
       end
     end
 

data/lib/fog/core/association.rb

@@ -7,6 +7,7 @@ module Fog
 
     def load(associations)
       return unless associations.kind_of?(Array)
+
       associations.each do |association|
         self << association
       end

data/lib/fog/core/attributes/default.rb

@@ -7,6 +7,13 @@ module Fog
     class Default
       attr_reader :model, :name, :squash, :aliases, :default, :as
 
+      # @param [Klass] model model class
+      # @param [Symbol] name name of the attribute
+      # @param [Hash] options attribute options
+      # @option options [Symbol] :squash
+      # @option options [::Array] :aliases
+      # @option options [Object] :default
+      # @option options [Object] :as
       def initialize(model, name, options)
         @model = model
         @model.attributes << name

data/lib/fog/core/attributes.rb

@@ -25,6 +25,14 @@ module Fog
         @masks ||= {}
       end
 
+      # Defines a new attribute
+      # @param [Symbol] name attribute name
+      # @param [Hash] options (see {Default#initialize})
+      # @option options [Symbol, ::String] :type attribute type (see {Attributes})
+      # @option options [Symbol] :squash
+      # @option options [::Array] :aliases
+      # @option options [Object] :default
+      # @option options [Object] :as
       def attribute(name, options = {})
         type = options.fetch(:type, "default").to_s.capitalize
         Fog::Attributes.const_get(type).new(self, name, options)
@@ -79,14 +87,26 @@ module Fog
 
       def all_attributes
         self.class.attributes.reduce({}) do |hash, attribute|
-          hash[masks[attribute]] = send(attribute)
+          if masks[attribute].nil?
+            Fog::Logger.deprecation("Please define #{attribute} using the Fog DSL")
+            hash[attribute] = send(attribute)
+          else
+            hash[masks[attribute]] = send(attribute)
+          end
+
           hash
         end
       end
 
       def all_associations
         self.class.associations.keys.reduce({}) do |hash, association|
-          hash[masks[association]] = associations[association] || send(association)
+          if masks[association].nil?
+            Fog::Logger.deprecation("Please define #{association} using the Fog DSL")
+            hash[association] = associations[association] || send(association)
+          else
+            hash[masks[association]] = associations[association] || send(association)
+          end
+
           hash
         end
       end
@@ -113,9 +133,13 @@ module Fog
         send("#{identity_name}=", new_identity)
       end
 
+      # Merges attributes into self
+      # @note Ignored attributes are not merged (see {ClassMethods.ignored_attributes})
+      # @return [self]
       def merge_attributes(new_attributes = {})
         new_attributes.each_pair do |key, value|
           next if self.class.ignored_attributes.include?(key)
+
           if self.class.aliases[key]
             send("#{self.class.aliases[key]}=", value)
           elsif self.respond_to?("#{key}=", true)
@@ -127,6 +151,18 @@ module Fog
         self
       end
 
+      # Filters attributes by selected attribute names
+      # @note In some cases we want to easily get subset of model attributes
+      # @note Hash#slice requires Ruby >= 2.5.0
+      # @param [Symbol] selected attribute names
+      # @return [Hash] new hash with selected attributes
+      def filter_attributes(*selected)
+        filtered = attributes.select { |a, _| selected.include?(a) }
+
+        # we should use getters instead of direct accessing attributes hash
+        filtered.each_key { |k| filtered[k] = send(k) }
+      end
+
       # Returns true if a remote resource has been assigned an
       # identity and we can assume it has been persisted.
       #
@@ -154,14 +190,15 @@ module Fog
         if missing.length == 1
           raise(ArgumentError, "#{missing.first} is required for this operation")
         elsif missing.any?
-          raise(ArgumentError, "#{missing[0...-1].join(", ")} and #{missing[-1]} are required for this operation")
+          raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
         end
       end
 
       def requires_one(*args)
         missing = missing_attributes(args)
         return unless missing.length == args.length
-        raise(ArgumentError, "#{missing[0...-1].join(", ")} or #{missing[-1]} are required for this operation")
+
+        raise(ArgumentError, "#{missing[0...-1].join(', ')} or #{missing[-1]} are required for this operation")
       end
 
       protected
@@ -169,7 +206,7 @@ module Fog
       def missing_attributes(args)
         missing = []
         ([:service] | args).each do |arg|
-          missing << arg unless send("#{arg}") || attributes.key?(arg)
+          missing << arg unless send(arg.to_s) || attributes.key?(arg)
         end
         missing
       end

data/lib/fog/core/cache.rb

@@ -93,6 +93,9 @@ module Fog
     # see the +namespace_prefix=+ method.
     SANDBOX = ENV["HOME"] ? File.expand_path("~/.fog-cache") : File.expand_path(".fog-cache")
 
+    # required attributes to load model from cache
+    REQUIRED_ATTRIBUTES = [:identity, :collection_klass, :collection_attrs, :model_klass, :model_attrs].freeze
+
     # when a resource is used such as `server.cache.dump` the model klass is passed in
     # so that it can be identified from a different session.
     attr_reader :model
@@ -112,26 +115,34 @@ module Fog
       # collection_klass and model_klass should be the same across all instances
       # choose a valid cache record from the dump to use as a sample to deterine
       # which collection/model to instantiate.
-      sample_path = cache_files.detect{ |path| valid_for_load?(path) }
-      model_klass = const_get_compat(load_cache(sample_path)[:model_klass])
-      collection_klass = const_get_compat(load_cache(sample_path)[:collection_klass]) if load_cache(sample_path)[:collection_klass]
+      sample_path = cache_files.detect { |path| valid_for_load?(path) }
+      model_klass = Object.const_get(load_cache(sample_path)[:model_klass])
+      collection_klass = Object.const_get(load_cache(sample_path)[:collection_klass]) if load_cache(sample_path)[:collection_klass]
 
       # Load the cache data into actual ruby instances
       loaded = cache_files.map do |path|
-          model_klass.new(load_cache(path)[:attrs]) if valid_for_load?(path)
-      end.compact
+        next unless valid_for_load?(path)
 
-      # Set the collection and service so they can be reloaded/connection is set properly.
-      # See https://github.com/fog/fog-aws/issues/354#issuecomment-286789702
-      loaded.each do |i|
-        i.collection = collection_klass.new(:service => service) if collection_klass
-        i.instance_variable_set(:@service, service)
-      end
+        cache = load_cache(path)
+
+        # make sure attributes are not nil
+        cache[:collection_attrs] ||= {}
+        cache[:model_attrs] ||= {}
+
+        m = model_klass.new(cache[:model_attrs])
+
+        # Set the collection and service so they can be reloaded/connection is set properly.
+        # See https://github.com/fog/fog-aws/issues/354#issuecomment-286789702
+        m.instance_variable_set(:@service, service)
+        m.collection = collection_klass.new(cache[:collection_attrs].merge(service: service)) if collection_klass
+
+        m
+      end.compact
 
       # uniqe-ify based on the total of attributes. duplicate cache can exist due to
       # `model#identity` not being unique. but if all attributes match, they are unique
       # and shouldn't be loaded again.
-      uniq_loaded = uniq_w_block(loaded) { |i| i.attributes }
+      uniq_loaded = loaded.uniq { |i| i.attributes }
       if uniq_loaded.size != loaded.size
         Fog::Logger.warning("Found duplicate items in the cache. Expire all & refresh cache soon.")
       end
@@ -142,38 +153,18 @@ module Fog
       uniq_loaded
     end
 
-    # :nodoc: compatability for 1.8.7 1.9.3
-    def self.const_get_compat(strklass)
-      # https://stackoverflow.com/questions/3163641/get-a-class-by-name-in-ruby
-      strklass.split('::').inject(Object) do |mod, class_name|
-        mod.const_get(class_name)
-      end
-    end
-
-    # :nodoc: compatability for 1.8.7 1.9.3
-    def self.uniq_w_block(arr)
-      ret, keys = [], []
-      arr.each do |x|
-        key = block_given? ? yield(x) : x
-        unless keys.include? key
-          ret << x
-          keys << key
-        end
-      end
-      ret
-    end
-
     # method to determine if a path can be loaded and is valid fog cache format.
     def self.valid_for_load?(path)
       data = load_cache(path)
       if data && data.is_a?(Hash)
-        if [:identity, :model_klass, :collection_klass, :attrs].all? { |k| data.keys.include?(k) }
-          return true
-        else
-          Fog::Logger.warning("Found corrupt items in the cache: #{path}. Expire all & refresh cache soon.\n\nData:#{File.read(path)}")
-          return false
-        end
+        missing_attrs = REQUIRED_ATTRIBUTES.reject { |k| data.keys.include?(k) }
+        return true if missing_attrs.empty?
+
+        Fog::Logger.warning("Found corrupt items in the cache: #{path}. Expire all & refresh cache soon.\n\nMissing: #{missing_attrs}.\nData:\n#{File.read(path)}")
+        return false
       end
+
+      false
     end
 
     # creates on-disk cache of this specific +model_klass+ and +@service+
@@ -193,12 +184,23 @@ module Fog
       FileUtils.rm_rf(SANDBOX)
     end
 
+    # Load YAML file with aliases
+    # @note Starting from Ruby 3.1 we must explicitly tell Psych to allow aliases
+    def self.yaml_load(path)
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.1.0")
+        YAML.load(path, aliases: true)
+      else
+        YAML.load(path)
+      end
+    end
+
     # loads yml cache from path on disk, used
     # to initialize Fog models.
     def self.load_cache(path)
       @memoized ||= {}
       return @memoized[path] if @memoized[path]
-      @memoized[path] = YAML.load(File.read(path))
+
+      @memoized[path] = yaml_load(File.read(path))
     end
 
     def self.namespace_prefix=(name)
@@ -222,13 +224,13 @@ module Fog
 
       mpath = File.join(SANDBOX, namespace_prefix, "metadata.yml")
       to_write = if File.exist?(mpath)
-                YAML.dump(YAML.load(File.read(mpath)).merge!(h))
-              else
-                YAML.dump(h)
-              end
+                   YAML.dump(yaml_load(File.read(mpath)).merge!(h))
+                 else
+                   YAML.dump(h)
+                 end
 
       mdir = File.join(SANDBOX, namespace_prefix)
-      FileUtils.mkdir_p(mdir) if !File.exist?(mdir)
+      FileUtils.mkdir_p(mdir)
 
       File.open(mpath, "w") { |f| f.write(to_write) }
     end
@@ -237,10 +239,9 @@ module Fog
     def self.metadata
       mpath = File.join(SANDBOX, namespace_prefix, "metadata.yml")
       if File.exist?(mpath)
-        metadata = YAML.load(File.read(mpath))
-        return metadata
+        yaml_load(File.read(mpath))
       else
-        return {}
+        {}
       end
     end
 
@@ -249,11 +250,10 @@ module Fog
 
       raise CacheDir.new("Must set an explicit identifier/name for this cache. Example: 'serviceX-regionY'") unless namespace_prefix
 
-      ns = File.join(SANDBOX, namespace_prefix, service.class.to_s, model_klass.to_s)
-      ns = safe_path(ns)
+      File.join(SANDBOX, namespace_prefix, safe_class_path(service.class), safe_class_path(model_klass))
     end
 
-    def self.safe_path(klass)
+    def self.safe_class_path(klass)
       klass.to_s.gsub("::", "_").downcase
     end
 
@@ -269,10 +269,13 @@ module Fog
         self.class.create_namespace(model.class, model.service)
       end
 
-      data = { :identity => model.identity,
-                     :model_klass => model.class.to_s,
-                     :collection_klass => model.collection && model.collection.class.to_s,
-                     :attrs => model.attributes }
+      data = {
+        identity: model.identity,
+        model_klass: model.class.to_s,
+        collection_klass: model.collection && model.collection.class.to_s,
+        collection_attrs: model.collection && model.collection.attributes,
+        model_attrs: model.attributes
+      }
 
       File.open(dump_to, "w") { |f| f.write(YAML.dump(data)) }
     end

data/lib/fog/core/collection.rb

@@ -11,6 +11,7 @@ module Fog
 
     Array.public_instance_methods(false).each do |method|
       next if [:reject, :select, :slice, :clear, :inspect].include?(method.to_sym)
+
       class_eval <<-EOS, __FILE__, __LINE__
         def #{method}(*args)
           unless @loaded
@@ -18,6 +19,7 @@ module Fog
           end
           super
         end
+        ruby2_keywords(method) if respond_to?(:ruby2_keywords, true)
       EOS
     end
 
@@ -30,6 +32,7 @@ module Fog
           data = super
           self.clone.clear.concat(data)
         end
+        ruby2_keywords(method) if respond_to?(:ruby2_keywords, true)
       EOS
     end
 
@@ -52,7 +55,7 @@ module Fog
     end
 
     def destroy(identity)
-      new(:identity => identity).destroy
+      new(identity: identity).destroy
     end
 
     # Creates a new Fog::Collection based around the passed service
@@ -85,10 +88,11 @@ module Fog
       unless attributes.is_a?(::Hash)
         raise ArgumentError, "Initialization parameters must be an attributes hash, got #{attributes.class} #{attributes.inspect}"
       end
+
       model.new(
         {
-          :collection => self,
-          :service => service
+          collection: self,
+          service: service
         }.merge(attributes)
       )
     end
@@ -112,6 +116,7 @@ module Fog
       all
     end
   end
+
   # Base class for collection classes whose 'all' method returns only a single
   # page of results and passes the 'Marker' option along as
   # self.filters[:marker]
@@ -120,6 +125,7 @@ module Fog
       if block_given?
         Kernel.loop do
           break unless filters[:marker]
+
           page = all(collection_filters)
           # We need to explicitly use the base 'each' method here on the page,
           #  otherwise we get infinite recursion

data/lib/fog/core/connection.rb

@@ -44,17 +44,15 @@ module Fog
       # @option params [Class] :instrumentor Responds to #instrument as in ActiveSupport::Notifications
       # @option params [String] :instrumentor_name Name prefix for #instrument events.  Defaults to 'excon'
       def initialize(url, persistent = false, params = {})
-        if params[:path_prefix]
-          if params[:path]
-            raise ArgumentError, "optional arg 'path' is invalid when 'path_prefix' is provided"
-          end
+        @path_prefix = params.delete(:path_prefix)
 
-          @path_prefix = params.delete(:path_prefix)
+        if @path_prefix && params[:path]
+          raise ArgumentError, "optional arg 'path' is invalid when 'path_prefix' is provided"
         end
 
         params[:debug_response] = true unless params.key?(:debug_response)
         params[:headers] ||= {}
-        params.merge!(:persistent => params.fetch(:persistent, persistent))
+        params.merge!(persistent: params.fetch(:persistent, persistent))
         params[:headers]["User-Agent"] ||= user_agent
         @excon = Excon.new(url, params)
       end

data/lib/fog/core/current_machine.rb

@@ -4,7 +4,7 @@ module Fog
   class CurrentMachine
     @lock = Mutex.new
 
-    AMAZON_AWS_CHECK_IP = "http://checkip.amazonaws.com"
+    AMAZON_AWS_CHECK_IP = "http://checkip.amazonaws.com".freeze
 
     def self.ip_address=(ip_address)
       @lock.synchronize do

data/lib/fog/core/errors.rb

@@ -120,7 +120,7 @@ An alternate file may be used by placing its path in the FOG_RC environment vari
 # End of Fog Credentials File
 #######################################################
 
-    YML
+      YML
       raise Fog::Errors::LoadError, missing_credentials_message
     end
   end

data/lib/fog/core/logger.rb

@@ -1,12 +1,15 @@
 module Fog
   class Logger
     @channels = {
-      :deprecation  => ::STDERR,
-      :warning      => ::STDERR
+      deprecation: ::STDERR,
+      warning: ::STDERR
     }
 
     @channels[:debug] = ::STDERR if ENV["DEBUG"]
 
+    # provide an env var with narrower scope in case of namespace conflicts
+    @channels[:debug] = ::STDERR if ENV["FOG_DEBUG"]
+
     def self.[](channel)
       @channels[channel]
     end

data/lib/fog/core/mock.rb

@@ -25,6 +25,7 @@ module Fog
 
     def self.delay=(new_delay)
       raise ArgumentError, "delay must be non-negative" unless new_delay >= 0
+
       @delay = new_delay
     end
 
@@ -32,7 +33,7 @@ module Fog
       raise Fog::Errors::MockNotImplemented, message
     end
 
-    def self.random_ip(opts = { :version => :v4 })
+    def self.random_ip(opts = { version: :v4 })
       version = opts[:version]
       if version == :v6
         bit_length = 128
@@ -80,7 +81,7 @@ module Fog
     end
 
     def self.random_selection(characters, length)
-      selection = ""
+      selection = +""
       length.times do
         position = rand(characters.length)
         selection << characters[position..position]
@@ -92,12 +93,15 @@ module Fog
       mocked_services = []
       Fog.constants.map do |x|
         next if Fog.autoload?(x)
+
         x_const = Fog.const_get(x)
         x_const.respond_to?(:constants) && x_const.constants.map do |y|
           next if x_const.autoload?(y)
+
           y_const = x_const.const_get(y)
           y_const.respond_to?(:constants) && y_const.constants.map do |z|
             next if y_const.autoload?(z)
+
             mocked_services << y_const.const_get(z) if z.to_sym == :Mock
           end
         end
@@ -105,6 +109,7 @@ module Fog
 
       mocked_services.each do |mocked_service|
         next unless mocked_service.respond_to?(:reset)
+
         mocked_service.reset
       end
     end

data/lib/fog/core/model.rb

@@ -21,6 +21,33 @@ module Fog
       merge_attributes(attribs)
     end
 
+    # Creates new or updates existing model
+    # @return [self]
+    def save
+      persisted? ? update : create
+    end
+
+    # Creates new entity from model
+    # @raise [Fog::Errors::NotImplemented] you must implement #create method in child class and return self
+    # @return [self]
+    def create
+      raise Fog::Errors::NotImplemented, "Implement method #create for #{self.class}. Method must return self"
+    end
+
+    # Updates new entity with model
+    # @raise [Fog::Errors::NotImplemented] you must implement #update method in child class and return self
+    # @return [self]
+    def update
+      raise Fog::Errors::NotImplemented, "Implement method #update for #{self.class}. Method must return self"
+    end
+
+    # Destroys entity by model identity
+    # @raise [Fog::Errors::NotImplemented] you must implement #destroy method in child class and return self
+    # @return [self]
+    def destroy
+      raise Fog::Errors::NotImplemented, "Implement method #destroy for #{self.class}. Method must return self"
+    end
+
     def cache
       Fog::Cache.new(self)
     end
@@ -41,6 +68,8 @@ module Fog
       end
     end
 
+    # @return [self] if model successfully reloaded
+    # @return [nil] if something went wrong or model was not found
     def reload
       requires :identity
 
@@ -61,6 +90,7 @@ module Fog
 
     def symbolize_keys(hash)
       return nil if hash.nil?
+
       hash.reduce({}) do |options, (key, value)|
         options[(key.to_sym rescue key) || key] = value
         options
@@ -69,6 +99,7 @@ module Fog
 
     def wait_for(timeout = Fog.timeout, interval = Fog.interval, &block)
       reload_has_succeeded = false
+
       duration = Fog.wait_for(timeout, interval) do # Note that duration = false if it times out
         if reload
           reload_has_succeeded = true
@@ -77,11 +108,9 @@ module Fog
           false
         end
       end
-      if reload_has_succeeded
-        return duration # false if timeout; otherwise {:duration => elapsed time }
-      else
-        raise Fog::Errors::Error, "Reload failed, #{self.class} #{identity} not present."
-      end
+      raise Fog::Errors::Error, "Reload failed, #{self.class} #{identity} not present." unless reload_has_succeeded
+
+      duration # false if timeout; otherwise {:duration => elapsed time }
     end
   end
 end