fog-core 2.1.0 → 2.3.0

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?
@@ -38,18 +28,6 @@ module Fog
           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)
       end

data/lib/fog/core/attributes.rb

@@ -79,14 +79,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

data/lib/fog/core/connection.rb

@@ -44,12 +44,10 @@ 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)

data/lib/fog/core/logger.rb

@@ -7,6 +7,9 @@ module Fog
 
     @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/provider.rb

@@ -8,9 +8,22 @@ module Fog
   end
 
   module Provider
-    def self.extended(base)
-      provider = base.to_s.split("::").last
-      Fog.providers[provider.downcase.to_sym] = provider
+    class << self
+      def extended(base)
+        provider = base.to_s.split("::").last
+        Fog.providers[provider.downcase.to_sym] = provider
+        Fog.providers[underscore_name(provider).to_sym] = provider
+      end
+    
+      private
+
+      def underscore_name(string)
+        string.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+      end
     end
 
     def [](service_key)
@@ -21,11 +34,31 @@ module Fog
       Fog.services[new_service] ||= []
       Fog.services[new_service] |= [to_s.split("::").last.downcase.to_sym]
       @services_registry ||= {}
-      @services_registry[new_service] = [to_s, constant_string].join("::")
+      @services_registry[new_service] = service_klass(constant_string)
     end
 
     def services
       @services_registry.keys
     end
+
+    # Returns service constant path, with provider, as string. If
+    # "provider::service" is defined (the preferred format) then it returns that
+    # string, otherwise it returns the deprecated string "service::provider".
+    def service_klass(constant_string)
+      if const_defined?([to_s, constant_string].join("::"))
+        [to_s, constant_string].join("::")
+      else
+        provider = to_s.split("::").last
+        Fog::Logger.deprecation("Unable to load #{[to_s, constant_string].join("::")}")
+        Fog::Logger.deprecation(
+          format(
+            Fog::ServicesMixin::E_SERVICE_PROVIDER_CONSTANT,
+            service: constant_string,
+            provider: provider
+          )
+        )
+        ['Fog', constant_string, provider].join("::")
+      end
+    end
   end
 end

data/lib/fog/core/scp.rb

@@ -64,8 +64,9 @@ module Fog
 
         @address  = address
         @username = username
-        @options  = { :paranoid => false, :verify_host_key => false }.merge(options)
+        @options  = { :paranoid => false, :verify_host_key => :never }.merge(options)
         @options.delete(:paranoid) if Net::SSH::VALID_OPTIONS.include? :verify_host_key
+        @options[:verify_host_key] = false unless Net::SSH::Verifiers.const_defined?(:Never)
       end
 
       def upload(local_path, remote_path, upload_options = {}, &block)

data/lib/fog/core/services_mixin.rb

@@ -1,21 +1,37 @@
 module Fog
   module ServicesMixin
+    E_SERVICE_PROVIDER_CONSTANT = <<-EOS.gsub(/\s+/, ' ').strip.freeze
+      Falling back to deprecated constant Fog::%<service>s::%<provider>s. The
+      preferred format of service provider constants has changed from
+      service::provider to provider::service. Please update this service
+      provider to use the preferred format.
+    EOS
+    E_SERVICE_PROVIDER_PATH = <<-EOS.gsub(/\s+/, ' ').strip.freeze
+      Falling back to deprecated path fog/%<service>s/%<provider>s. The
+      preferred file path format has changed from service/provider to
+      provider/service. Please update this service provider to use the preferred
+      format.
+    EOS
+
     def [](provider)
       new(:provider => provider)
     end
 
     def new(attributes)
-      attributes    = attributes.dup # Prevent delete from having side effects
-      provider      = attributes.delete(:provider).to_s.downcase.to_sym
-      provider_name = Fog.providers[provider]
+      attributes     = attributes.dup # Prevent delete from having side effects
+      provider       = attributes.delete(:provider).to_s.downcase.to_sym
+      provider_alias = check_provider_alias(provider)
+      provider_name  = Fog.providers[provider_alias]
 
-      raise ArgumentError, "#{provider} is not a recognized provider" unless providers.include?(provider)
+      raise ArgumentError, "#{provider_alias} is not a recognized provider" unless providers.include?(provider) || providers.include?(provider_alias)
 
-      require_service_provider_library(service_name.downcase, provider)
+      require_service_provider_library(service_name.downcase, provider_alias)
       spc = service_provider_constant(service_name, provider_name)
       spc.new(attributes)
-    rescue LoadError, NameError  # Only rescue errors in finding the libraries, allow connection errors through to the caller
-      raise Fog::Service::NotFound, "#{provider} has no #{service_name.downcase} service"
+    rescue LoadError, NameError => e  # Only rescue errors in finding the libraries, allow connection errors through to the caller
+      Fog::Logger.warning("Error while loading provider #{provider_alias}: #{e.message}")
+      Fog::Logger.debug("backtrace: #{e.backtrace.join("\n")}")
+      raise Fog::Service::NotFound, "#{provider_alias} has no #{service_name.downcase} service"
     end
 
     def providers
@@ -24,16 +40,28 @@ module Fog
 
     private
 
+    # This method should be removed once all providers are extracted.
+    # Bundler will correctly require all dependencies automatically and thus
+    # fog-core wont need to know any specifics providers. Each provider will
+    # have to load its dependencies.
     def require_service_provider_library(service, provider)
       require "fog/#{provider}/#{service}"
     rescue LoadError  # Try to require the service provider in an alternate location
+      Fog::Logger.deprecation("Unable to require fog/#{provider}/#{service}")
+      Fog::Logger.deprecation(
+        format(E_SERVICE_PROVIDER_PATH, service: service, provider: provider)
+      )
       require "fog/#{service}/#{provider}"
     end
 
     def service_provider_constant(service_name, provider_name)
-      Fog.const_get(service_name).const_get(*const_get_args(provider_name))
-    rescue NameError  # Try to find the constant from in an alternate location
       Fog.const_get(provider_name).const_get(*const_get_args(service_name))
+    rescue NameError  # Try to find the constant from in an alternate location
+      Fog::Logger.deprecation("Unable to load Fog::#{provider_name}::#{service_name}")
+      Fog::Logger.deprecation(
+        format(E_SERVICE_PROVIDER_CONSTANT, service: service_name, provider: provider_name)
+      )
+      Fog.const_get(service_name).const_get(*const_get_args(provider_name))
     end
 
     def const_get_args(*args)
@@ -43,5 +71,29 @@ module Fog
     def service_name
       name.split("Fog::").last
     end
+
+    def check_provider_alias(provider)
+      case provider
+      when :baremetalcloud
+        Fog::Logger.deprecation(':baremetalcloud is deprecated. Use :bare_metal_cloud instead!')
+        :bare_metal_cloud
+      when :gogrid
+        Fog::Logger.deprecation(':gogrid is deprecated. Use :go_grid instead!')
+        :go_grid
+      when :internetarchive
+        Fog::Logger.deprecation(':internetarchive is deprecated. Use :internet_archive instead!')
+        :internet_archive
+      when :new_servers
+        Fog::Logger.deprecation(':new_servers is deprecated. Use :bare_metal_cloud instead!')
+        :bare_metal_cloud
+      when :stormondemand
+        Fog::Logger.deprecation(':stormondemand is deprecated. Use :storm_on_demand instead!')
+        :storm_on_demand
+      when :vclouddirector
+        Fog::Logger.deprecation(':vclouddirector is deprecated. Use :vcloud_director instead!')
+        :vcloud_director
+      else provider
+      end
+    end
   end
 end

data/lib/fog/core/ssh.rb

@@ -34,32 +34,10 @@ module Fog
 
     class Real
       def initialize(address, username, options)
-        begin
-          require "net/ssh"
-        rescue LoadError
-          Fog::Logger.warning("'net/ssh' missing, please install and try again.")
-          exit(1)
-        end
-
-        key_manager = Net::SSH::Authentication::KeyManager.new(nil, options)
-
-        unless options[:key_data] || options[:keys] || options[:password] || key_manager.agent
-          raise ArgumentError, ":key_data, :keys, :password or a loaded ssh-agent is required to initialize SSH"
-        end
-
-        options[:timeout] ||= 30
-        if options[:key_data] || options[:keys]
-          options[:keys_only] = true
-          # Explicitly set these so net-ssh doesn"t add the default keys
-          # as seen at https://github.com/net-ssh/net-ssh/blob/master/lib/net/ssh/authentication/session.rb#L131-146
-          options[:keys] = [] unless options[:keys]
-          options[:key_data] = [] unless options[:key_data]
-        end
-
+        assert_net_ssh_loaded
         @address  = address
         @username = username
-        @options  = { :paranoid => false, :verify_host_key => false }.merge(options)
-        @options.delete(:paranoid) if Net::SSH::VALID_OPTIONS.include? :verify_host_key
+        @options = build_options(options)
       end
 
       def run(commands, &blk)
@@ -107,6 +85,51 @@ module Fog
         end
         results
       end
+
+      private
+
+      def assert_net_ssh_loaded
+        begin
+          require "net/ssh"
+        rescue LoadError
+          Fog::Logger.warning("'net/ssh' missing, please install and try again.")
+          exit(1)
+        end
+      end
+
+      # Modifies the given `options` hash AND returns a new hash.
+      # TODO: Probably shouldn't modify the given hash.
+      def build_options(options)
+        validate_options(options)
+        merge_default_options_into(options)
+      end
+
+      def merge_default_options_into(options)
+        options[:timeout] ||= 30
+        if options[:key_data] || options[:keys]
+          options[:keys_only] = true
+          # Explicitly set these so net-ssh doesn"t add the default keys
+          # as seen at https://github.com/net-ssh/net-ssh/blob/master/lib/net/ssh/authentication/session.rb#L131-146
+          options[:keys] = [] unless options[:keys]
+          options[:key_data] = [] unless options[:key_data]
+        end
+
+        # net-ssh has deprecated :paranoid in favor of :verify_host_key
+        # https://github.com/net-ssh/net-ssh/pull/524
+        opts = { :paranoid => false, :verify_host_key => :never }.merge(options)
+        if Net::SSH::VALID_OPTIONS.include? :verify_host_key
+          opts.delete(:paranoid)
+        end
+        opts[:verify_host_key] = false unless Net::SSH::Verifiers.const_defined?(:Never)
+        opts
+      end
+
+      def validate_options(options)
+        key_manager = Net::SSH::Authentication::KeyManager.new(nil, options)
+        unless options[:key_data] || options[:keys] || options[:password] || key_manager.agent
+          raise ArgumentError, ":key_data, :keys, :password or a loaded ssh-agent is required to initialize SSH"
+        end
+      end
     end
 
     class Result

data/lib/fog/core/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module Core
-    VERSION = "2.1.0"
+    VERSION = "2.3.0"
   end
 end

data/lib/fog/dns.rb

@@ -2,17 +2,6 @@ module Fog
   module DNS
     extend Fog::ServicesMixin
 
-    def self.new(orig_attributes)
-      attributes = orig_attributes.dup # prevent delete from having side effects
-      case attributes.delete(:provider).to_s.downcase.to_sym
-      when :stormondemand
-        require "fog/dns/storm_on_demand"
-        Fog::DNS::StormOnDemand.new(attributes)
-      else
-        super(orig_attributes)
-      end
-    end
-
     def self.zones
       zones = []
       providers.each do |provider|

data/lib/fog/monitoring.rb

@@ -1,16 +1,5 @@
 module Fog
   module Monitoring
     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/monitoring/storm_on_demand"
-        Fog::Monitoring::StormOnDemand.new(attributes)
-      else
-        super(orig_attributes)
-      end
-    end
   end
 end

data/lib/fog/network.rb

@@ -1,17 +1,5 @@
 module Fog
   module Network
     extend Fog::ServicesMixin
-
-    def self.new(orig_attributes)
-      attributes = orig_attributes.dup # Prevent delete from having side effects
-      provider = attributes.delete(:provider).to_s.downcase.to_sym
-
-      if provider == :stormondemand
-        require "fog/network/storm_on_demand"
-        return Fog::Network::StormOnDemand.new(attributes)
-      else
-        super(orig_attributes)
-      end
-    end
   end
 end

data/lib/fog/storage.rb

@@ -9,20 +9,6 @@ module Fog
   module Storage
     extend Fog::ServicesMixin
 
-    def self.new(orig_attributes)
-      attributes = orig_attributes.dup # prevent delete from having side effects
-      case attributes.delete(:provider).to_s.downcase.to_sym
-      when :internetarchive
-        require "fog/internet_archive/storage"
-        Fog::Storage::InternetArchive.new(attributes)
-      when :stormondemand
-        require "fog/storage/storm_on_demand"
-        Fog::Storage::StormOnDemand.new(attributes)
-      else
-        super(orig_attributes)
-      end
-    end
-
     def self.directories
       directories = []
       providers.each do |provider|

data/lib/fog/support.rb

@@ -1,17 +1,5 @@
 module Fog
   module Support
     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/support/storm_on_demand"
-        Fog::Support::StormOnDemand.new(attributes)
-      else
-        super(orig_attributes)
-      end
-    end
   end
 end

data/lib/fog/test_helpers/succeeds_helper.rb

@@ -1,8 +1,8 @@
 module Shindo
   class Tests
-    def succeeds
+    def succeeds(&block)
       test("succeeds") do
-        !!instance_eval(&Proc.new)
+        !!instance_eval(&block)
       end
     end
   end

data/lib/fog/vpn.rb

@@ -1,17 +1,5 @@
 module Fog
   module VPN
     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/vpn/storm_on_demand"
-        Fog::VPN::StormOnDemand.new(attributes)
-      else
-        super(orig_attributes)
-      end
-    end
   end
 end

data/spec/compute_spec.rb

@@ -10,74 +10,74 @@ describe "Fog::Compute" do
   describe "#new" do
     module Fog
       module TheRightWay
-        extend Provider
-        service(:compute, "Compute")
+        class Compute
+          def initialize(_args); end
+        end
       end
     end
 
     module Fog
-      module Compute
-        class TheRightWay
-          def initialize(_args); end
-        end
+      module TheRightWay
+        extend Provider
+        service(:compute, "Compute")
       end
     end
 
     it "instantiates an instance of Fog::Compute::<Provider> from the :provider keyword arg" do
       compute = Fog::Compute.new(:provider => :therightway)
-      assert_instance_of(Fog::Compute::TheRightWay, compute)
+      assert_instance_of(Fog::TheRightWay::Compute, compute)
     end
 
     module Fog
-      module TheWrongWay
-        extend Provider
-        service(:compute, "Compute")
+      module Compute
+        class TheWrongWay
+          def initialize(_args); end
+        end
       end
     end
 
     module Fog
       module TheWrongWay
-        class Compute
-          def initialize(_args); end
-        end
+        extend Provider
+        service(:compute, "Compute")
       end
     end
 
     it "instantiates an instance of Fog::<Provider>::Compute from the :provider keyword arg" do
       compute = Fog::Compute.new(:provider => :thewrongway)
-      assert_instance_of(Fog::TheWrongWay::Compute, compute)
+      assert_instance_of(Fog::Compute::TheWrongWay, compute)
     end
 
     module Fog
       module BothWays
-        extend Provider
-        service(:compute, "Compute")
+        class Compute
+          attr_reader :args
+          def initialize(args)
+            @args = args
+          end
+        end
       end
     end
 
     module Fog
-      module BothWays
-        class Compute
+      module Compute
+        class BothWays
           def initialize(_args); end
         end
       end
     end
 
     module Fog
-      module Compute
-        class BothWays
-          attr_reader :args
-          def initialize(args)
-            @args = args
-          end
-        end
+      module BothWays
+        extend Provider
+        service(:compute, "Compute")
       end
     end
 
     describe "when both Fog::Compute::<Provider> and Fog::<Provider>::Compute exist" do
-      it "prefers Fog::Compute::<Provider>" do
+      it "prefers Fog::<Provider>::Compute" do
         compute = Fog::Compute.new(:provider => :bothways)
-        assert_instance_of(Fog::Compute::BothWays, compute)
+        assert_instance_of(Fog::BothWays::Compute, compute)
       end
     end
 

data/spec/core/cache_spec.rb

@@ -87,7 +87,7 @@ describe Fog::Cache do
       f.write(data)
     }
 
-    assert_equal false, Fog::Cache.load_cache(path)
+    assert !Fog::Cache.load_cache(path)
   end
 
   it "must have a namespace_prefix configurable" do