chef-provisioning-fog 0.26.1 → 0.26.3

data/lib/chef/provisioning/fog_driver/providers/aws/credentials.rb

@@ -1,115 +1,113 @@
-require 'inifile'
-require 'csv'
-require 'chef/mixin/deep_merge'
+require "inifile"
+require "csv"
+require "chef/mixin/deep_merge"
 
 class Chef
-module Provisioning
-module FogDriver
-  module Providers
-    class AWS
-      # Reads in a credentials file in Amazon's download format and presents the credentials to you
-      class Credentials
-        def initialize
-          @credentials = {}
-        end
+  module Provisioning
+    module FogDriver
+      module Providers
+        class AWS
+          # Reads in a credentials file in Amazon's download format and presents the credentials to you
+          class Credentials
+            def initialize
+              @credentials = {}
+            end
 
-        include Enumerable
-        include Chef::Mixin::DeepMerge
+            include Enumerable
+            include Chef::Mixin::DeepMerge
 
-        def default
-          if @credentials.size == 0
-            raise "No credentials loaded!  Do you have one of ~/.aws/credentials or ~/.aws/config?"
-          end
-          @credentials[ENV['AWS_DEFAULT_PROFILE'] || 'default'] || @credentials.first[1]
-        end
+            def default
+              if @credentials.empty?
+                raise "No credentials loaded!  Do you have one of ~/.aws/credentials or ~/.aws/config?"
+              end
+              @credentials[ENV["AWS_DEFAULT_PROFILE"] || "default"] || @credentials.first[1]
+            end
 
-        def keys
-          @credentials.keys
-        end
+            def keys
+              @credentials.keys
+            end
 
-        def [](name)
-          @credentials[name]
-        end
+            def [](name)
+              @credentials[name]
+            end
 
-        def each(&block)
-          @credentials.each(&block)
-        end
+            def each(&block)
+              @credentials.each(&block)
+            end
 
-        def load_inis(config_ini_file, credentials_ini_file = nil)
-          @credentials = load_config_ini(config_ini_file)
-          @credentials = deep_merge!(@credentials,
-                                     load_credentials_ini(credentials_ini_file)
-                                    ) if credentials_ini_file
-        end
+            def load_inis(config_ini_file, credentials_ini_file = nil)
+              @credentials = load_config_ini(config_ini_file)
+              if credentials_ini_file
+                @credentials = deep_merge!(@credentials,
+                                           load_credentials_ini(credentials_ini_file))
+              end
+            end
 
-        def load_config_ini(config_ini_file)
-          inifile = IniFile.load(File.expand_path(config_ini_file))
-          config = {}
-          if inifile
-            inifile.each_section do |section|
-              if section =~ /^\s*profile\s+(.+)$/ || section =~ /^\s*(default)\s*/
-                profile_name = $1.strip
-                profile = inifile[section].inject({}) do |result, pair|
-                  result[pair[0].to_sym] = pair[1]
-                  result
+            def load_config_ini(config_ini_file)
+              inifile = IniFile.load(File.expand_path(config_ini_file))
+              config = {}
+              if inifile
+                inifile.each_section do |section|
+                  next unless section =~ /^\s*profile\s+(.+)$/ || section =~ /^\s*(default)\s*/
+                  profile_name = Regexp.last_match(1).strip
+                  profile = inifile[section].each_with_object({}) do |pair, result|
+                    result[pair[0].to_sym] = pair[1]
+                  end
+                  profile[:name] = profile_name
+                  config[profile_name] = profile
                 end
-                profile[:name] = profile_name
-                config[profile_name] = profile
               end
+              config
             end
-          end
-          config
-        end
 
-        def load_credentials_ini(credentials_ini_file)
-          inifile = IniFile.load(File.expand_path(credentials_ini_file))
-          config = {}
-          if inifile
-            inifile.each_section do |section|
-              profile = inifile[section].inject({}) do |result, pair|
-                result[pair[0].to_sym] = pair[1]
-                result
+            def load_credentials_ini(credentials_ini_file)
+              inifile = IniFile.load(File.expand_path(credentials_ini_file))
+              config = {}
+              if inifile
+                inifile.each_section do |section|
+                  profile = inifile[section].each_with_object({}) do |pair, result|
+                    result[pair[0].to_sym] = pair[1]
+                  end
+                  profile[:name] = section
+                  config[section] = profile
+                end
               end
-              profile[:name] = section
-              config[section] = profile
+              config
             end
-          end
-          config
-        end
 
-        def load_csv(credentials_csv_file)
-          CSV.new(File.open(credentials_csv_file), :headers => :first_row).each do |row|
-            @credentials[row['User Name']] = {
-              :name => row['User Name'],
-              :user_name => row['User Name'],
-              :aws_access_key_id => row['Access Key Id'],
-              :aws_secret_access_key => row['Secret Access Key']
-            }
-          end
-        end
+            def load_csv(credentials_csv_file)
+              CSV.new(File.open(credentials_csv_file), headers: :first_row).each do |row|
+                @credentials[row["User Name"]] = {
+                  name: row["User Name"],
+                  user_name: row["User Name"],
+                  aws_access_key_id: row["Access Key Id"],
+                  aws_secret_access_key: row["Secret Access Key"]
+                }
+              end
+            end
 
-        def load_default
-          config_file = ENV['AWS_CONFIG_FILE'] || File.expand_path('~/.aws/config')
-          credentials_file = ENV['AWS_CREDENTIAL_FILE'] || File.expand_path('~/.aws/credentials')
-          if File.file?(config_file)
-            if File.file?(credentials_file)
-              load_inis(config_file, credentials_file)
-            else
-              load_inis(config_file)
+            def load_default
+              config_file = ENV["AWS_CONFIG_FILE"] || File.expand_path("~/.aws/config")
+              credentials_file = ENV["AWS_CREDENTIAL_FILE"] || File.expand_path("~/.aws/credentials")
+              if File.file?(config_file)
+                if File.file?(credentials_file)
+                  load_inis(config_file, credentials_file)
+                else
+                  load_inis(config_file)
+                end
+              end
             end
-          end
-        end
 
-        def self.method_missing(name, *args, &block)
-          singleton.send(name, *args, &block)
-        end
+            def self.method_missing(name, *args, &block)
+              singleton.send(name, *args, &block)
+            end
 
-        def self.singleton
-          @aws_credentials ||= Credentials.new
+            def self.singleton
+              @aws_credentials ||= Credentials.new
+            end
+          end
         end
       end
     end
   end
 end
-end
-end

data/lib/chef/provisioning/fog_driver/providers/cloudstack.rb

@@ -1,44 +1,42 @@
 class Chef
-module Provisioning
-module FogDriver
-  module Providers
-    class CloudStack < FogDriver::Driver
+  module Provisioning
+    module FogDriver
+      module Providers
+        class CloudStack < FogDriver::Driver
+          Driver.register_provider_class("CloudStack", FogDriver::Providers::CloudStack)
 
-      Driver.register_provider_class('CloudStack', FogDriver::Providers::CloudStack)
+          def creator
+            ""
+          end
 
-      def creator
-        ''
-      end
-
-      def self.compute_options_for(provider, id, config)
-        new_compute_options = {}
-        new_compute_options[:provider] = provider
-        new_config = { :driver_options => { :compute_options => new_compute_options }}
-        new_defaults = {
-          :driver_options => { :compute_options => {} },
-          :machine_options => { :bootstrap_options => {} }
-        }
-        result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
+          def self.compute_options_for(provider, id, config)
+            new_compute_options = {}
+            new_compute_options[:provider] = provider
+            new_config = { driver_options: { compute_options: new_compute_options } }
+            new_defaults = {
+              driver_options: { compute_options: {} },
+              machine_options: { bootstrap_options: {} }
+            }
+            result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
 
-        if id && id != ''
-          cloudstack_uri = URI.parse(id)
-          new_compute_options[:cloudstack_scheme] = cloudstack_uri.scheme
-          new_compute_options[:cloudstack_host]   = cloudstack_uri.host
-          new_compute_options[:cloudstack_port]   = cloudstack_uri.port
-          new_compute_options[:cloudstack_path]   = cloudstack_uri.path
-        end
+            if id && id != ""
+              cloudstack_uri = URI.parse(id)
+              new_compute_options[:cloudstack_scheme] = cloudstack_uri.scheme
+              new_compute_options[:cloudstack_host]   = cloudstack_uri.host
+              new_compute_options[:cloudstack_port]   = cloudstack_uri.port
+              new_compute_options[:cloudstack_path]   = cloudstack_uri.path
+            end
 
-        host   = result[:driver_options][:compute_options][:cloudstack_host]
-        path   = result[:driver_options][:compute_options][:cloudstack_path]    || '/client/api'
-        port   = result[:driver_options][:compute_options][:cloudstack_port]    || 443
-        scheme = result[:driver_options][:compute_options][:cloudstack_scheme]  || 'https'
-        id = URI.scheme_list[scheme.upcase].build(:host => host, :port => port, :path => path).to_s
+            host   = result[:driver_options][:compute_options][:cloudstack_host]
+            path   = result[:driver_options][:compute_options][:cloudstack_path]    || "/client/api"
+            port   = result[:driver_options][:compute_options][:cloudstack_port]    || 443
+            scheme = result[:driver_options][:compute_options][:cloudstack_scheme]  || "https"
+            id = URI.scheme_list[scheme.upcase].build(host: host, port: port, path: path).to_s
 
-        [result, id]
+            [result, id]
+          end
+        end
       end
-
     end
   end
 end
-end
-end

data/lib/chef/provisioning/fog_driver/providers/digitalocean.rb

@@ -1,119 +1,117 @@
 #   fog:DigitalOcean:<client id>
 class Chef
-module Provisioning
-module FogDriver
-  module Providers
-    class DigitalOcean < FogDriver::Driver
-      Driver.register_provider_class('DigitalOcean', FogDriver::Providers::DigitalOcean)
+  module Provisioning
+    module FogDriver
+      module Providers
+        class DigitalOcean < FogDriver::Driver
+          Driver.register_provider_class("DigitalOcean", FogDriver::Providers::DigitalOcean)
 
-      def creator
-        ''
-      end
+          def creator
+            ""
+          end
 
-      def convergence_strategy_for(machine_spec, machine_options)
-        machine_options = Cheffish::MergedConfig.new(machine_options, {
-                                                       :convergence_options => {:ohai_hints => {'digital_ocean' => {}}}
-                                                     })
-        super(machine_spec, machine_options)
-      end
+          def convergence_strategy_for(machine_spec, machine_options)
+            machine_options = Cheffish::MergedConfig.new(machine_options,
+                                                         convergence_options: { ohai_hints: { "digital_ocean" => {} } })
+            super(machine_spec, machine_options)
+          end
 
-      def converge_floating_ips(action_handler, machine_spec, machine_options, server)
-        # DigitalOcean does not have floating IPs
-      end
+          def converge_floating_ips(action_handler, machine_spec, machine_options, server)
+            # DigitalOcean does not have floating IPs
+          end
 
-      def bootstrap_options_for(action_handler, machine_spec, machine_options)
-        bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
-        if bootstrap_options[:key_path] || bootstrap_options[:key_name]
-          bootstrap_options[:key_name] ||= File.basename(bootstrap_options[:key_path])
-          # Verify that the provided key name and path are in line (or create the key pair if not!)
-          driver = self
-          Provisioning.inline_resource(action_handler) do
-            fog_key_pair bootstrap_options[:key_name] do
-              private_key_path bootstrap_options[:key_path]
-              driver driver
+          def bootstrap_options_for(action_handler, machine_spec, machine_options)
+            bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
+            if bootstrap_options[:key_path] || bootstrap_options[:key_name]
+              bootstrap_options[:key_name] ||= File.basename(bootstrap_options[:key_path])
+              # Verify that the provided key name and path are in line (or create the key pair if not!)
+              driver = self
+              Provisioning.inline_resource(action_handler) do
+                fog_key_pair bootstrap_options[:key_name] do
+                  private_key_path bootstrap_options[:key_path]
+                  driver driver
+                end
+              end
+            else
+              bootstrap_options[:key_name] ||= overwrite_default_key_willy_nilly(action_handler, machine_spec)
             end
-          end
-        else
-          bootstrap_options[:key_name] ||= overwrite_default_key_willy_nilly(action_handler, machine_spec)
-        end
 
-        bootstrap_options[:tags]  = default_tags(machine_spec, bootstrap_options[:tags] || {})
+            bootstrap_options[:tags] = default_tags(machine_spec, bootstrap_options[:tags] || {})
 
-        if !bootstrap_options[:image_id] && !bootstrap_options[:image]
-          if !bootstrap_options[:image_distribution] && !bootstrap_options[:image_name]
-            bootstrap_options[:image_distribution] = 'CentOS'
-            bootstrap_options[:image_name] = '6.5 x64'
-          end
-          distributions = compute.images.select { |image| image.distribution == bootstrap_options[:image_distribution] }
-          if distributions.empty?
-            raise "No images on DigitalOcean with distribution #{bootstrap_options[:image_distribution].inspect}"
-          end
-          images = distributions.select { |image| image.name == bootstrap_options[:image_name] } if bootstrap_options[:image_name]
-          if images.empty?
-            raise "No images on DigitalOcean with distribution #{bootstrap_options[:image_distribution].inspect} and name #{bootstrap_options[:image_name].inspect}"
-          end
-          bootstrap_options[:image] = images.first.id
-        end
-        if !bootstrap_options[:flavor_id] && !bootstrap_options[:size]
-          bootstrap_options[:flavor_name] ||= '512MB'
-          flavors = compute.flavors.select do |f|
-            f.slug.downcase == bootstrap_options[:flavor_name].downcase
-          end
-          if flavors.empty?
-            raise "Could not find flavor named '#{bootstrap_options[:flavor_name]}' on #{driver_url}"
-          end
-          bootstrap_options[:size] = flavors.first.slug
-        end
-        if !bootstrap_options[:region]
-          bootstrap_options[:region_name] ||= 'San Francisco 1'
-          regions = compute.regions.select { |region| region.name == bootstrap_options[:region_name] }
-          if regions.empty?
-            raise "Could not find region named '#{bootstrap_options[:region_name]}' on #{driver_url}"
-          end
-          bootstrap_options[:region] = regions.first.slug
-        end
-        keys = compute.ssh_keys.select { |k| k.name == bootstrap_options[:key_name] }
-        if keys.empty?
-          raise "Could not find key named '#{bootstrap_options[:key_name]}' on #{driver_url}"
-        end
-        found_key = keys.first
-        bootstrap_options[:ssh_keys] ||= [ found_key.id ]
+            if !bootstrap_options[:image_id] && !bootstrap_options[:image]
+              if !bootstrap_options[:image_distribution] && !bootstrap_options[:image_name]
+                bootstrap_options[:image_distribution] = "CentOS"
+                bootstrap_options[:image_name] = "6.5 x64"
+              end
+              distributions = compute.images.select { |image| image.distribution == bootstrap_options[:image_distribution] }
+              if distributions.empty?
+                raise "No images on DigitalOcean with distribution #{bootstrap_options[:image_distribution].inspect}"
+              end
+              images = distributions.select { |image| image.name == bootstrap_options[:image_name] } if bootstrap_options[:image_name]
+              if images.empty?
+                raise "No images on DigitalOcean with distribution #{bootstrap_options[:image_distribution].inspect} and name #{bootstrap_options[:image_name].inspect}"
+              end
+              bootstrap_options[:image] = images.first.id
+            end
+            if !bootstrap_options[:flavor_id] && !bootstrap_options[:size]
+              bootstrap_options[:flavor_name] ||= "512MB"
+              flavors = compute.flavors.select do |f|
+                f.slug.casecmp(bootstrap_options[:flavor_name]).zero?
+              end
+              if flavors.empty?
+                raise "Could not find flavor named '#{bootstrap_options[:flavor_name]}' on #{driver_url}"
+              end
+              bootstrap_options[:size] = flavors.first.slug
+            end
+            unless bootstrap_options[:region]
+              bootstrap_options[:region_name] ||= "San Francisco 1"
+              regions = compute.regions.select { |region| region.name == bootstrap_options[:region_name] }
+              if regions.empty?
+                raise "Could not find region named '#{bootstrap_options[:region_name]}' on #{driver_url}"
+              end
+              bootstrap_options[:region] = regions.first.slug
+            end
+            keys = compute.ssh_keys.select { |k| k.name == bootstrap_options[:key_name] }
+            if keys.empty?
+              raise "Could not find key named '#{bootstrap_options[:key_name]}' on #{driver_url}"
+            end
+            found_key = keys.first
+            bootstrap_options[:ssh_keys] ||= [found_key.id]
 
-        # You don't get to specify name yourself
-        bootstrap_options[:name] = machine_spec.name
-        bootstrap_options[:version] ||= :v2
-        bootstrap_options
-      end
+            # You don't get to specify name yourself
+            bootstrap_options[:name] = machine_spec.name
+            bootstrap_options[:version] ||= :v2
+            bootstrap_options
+          end
 
-      def destroy_machine(action_handler, machine_spec, machine_options)
-        server = server_for(machine_spec)
-        if server && server.status != 'archive'
-          action_handler.perform_action "destroy machine #{machine_spec.name} (#{machine_spec.location['server_id']} at #{driver_url})" do
-            server.delete
+          def destroy_machine(action_handler, machine_spec, machine_options)
+            server = server_for(machine_spec)
+            if server && server.status != "archive"
+              action_handler.perform_action "destroy machine #{machine_spec.name} (#{machine_spec.location['server_id']} at #{driver_url})" do
+                server.delete
+              end
+            end
+            machine_spec.location = nil
+            strategy = convergence_strategy_for(machine_spec, machine_options)
+            strategy.cleanup_convergence(action_handler, machine_spec)
           end
-        end
-        machine_spec.location = nil
-        strategy = convergence_strategy_for(machine_spec, machine_options)
-        strategy.cleanup_convergence(action_handler, machine_spec)
-      end
 
-      def self.compute_options_for(provider, id, config)
-        new_compute_options = {}
-        new_compute_options[:provider] = provider
-        new_config = { :driver_options => { :compute_options => new_compute_options }}
-        new_defaults = {
-          :driver_options  => { :compute_options => { version: :v2 } },
-          :machine_options => { :bootstrap_options => {}, :ssh_options => {} }
-        }
-        result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
+          def self.compute_options_for(provider, id, config)
+            new_compute_options = {}
+            new_compute_options[:provider] = provider
+            new_config = { driver_options: { compute_options: new_compute_options } }
+            new_defaults = {
+              driver_options: { compute_options: { version: :v2 } },
+              machine_options: { bootstrap_options: {}, ssh_options: {} }
+            }
+            result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
 
-        new_compute_options[:digitalocean_token] = id if (id && id != '')
+            new_compute_options[:digitalocean_token] = id if id && id != ""
 
-        [result, new_compute_options[:digitalocean_token]]
+            [result, new_compute_options[:digitalocean_token]]
+          end
+        end
       end
-
     end
   end
 end
-end
-end