chef-provisioning-fog 0.26.1 → 0.26.3

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

@@ -3,28 +3,22 @@ class Chef
     module FogDriver
       module Providers
         class Google < FogDriver::Driver
-          Driver.register_provider_class('Google', FogDriver::Providers::Google)
+          Driver.register_provider_class("Google", FogDriver::Providers::Google)
 
           def creator
-            ''
+            ""
           end
 
           def convergence_strategy_for(machine_spec, machine_options)
-            machine_options = Cheffish::MergedConfig.new(machine_options, {
-                                                           :convergence_options => {:ohai_hints => {'gce' => {}}}
-                                                         })
+            machine_options = Cheffish::MergedConfig.new(machine_options,
+                                                         convergence_options: { ohai_hints: { "gce" => {} } })
             super(machine_spec, machine_options)
           end
 
-          def converge_floating_ips(action_handler, machine_spec, machine_options, server)
-          end
+          def converge_floating_ips(action_handler, machine_spec, machine_options, server); end
 
           def server_for(machine_spec)
-            if machine_spec.name
-              compute.servers.get(machine_spec.name)
-            else
-              nil
-            end
+            compute.servers.get(machine_spec.name) if machine_spec.name
           end
 
           def servers_for(machine_specs)
@@ -35,29 +29,29 @@ class Chef
             result
           end
 
-          def bootstrap_options_for(action_handler, machine_spec, machine_options)
+          def bootstrap_options_for(_action_handler, machine_spec, machine_options)
             bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
-            bootstrap_options[:image_name] ||= 'debian-7-wheezy-v20150325'
-            bootstrap_options[:machine_type] ||= 'n1-standard-1'
-            bootstrap_options[:zone_name] ||= 'europe-west1-b'
+            bootstrap_options[:image_name] ||= "debian-7-wheezy-v20150325"
+            bootstrap_options[:machine_type] ||= "n1-standard-1"
+            bootstrap_options[:zone_name] ||= "europe-west1-b"
             bootstrap_options[:name] ||= machine_spec.name
             bootstrap_options[:disk_size] ||= 10
             disk_type_prefix = "https://www.googleapis.com/compute/v1/projects/#{compute_options[:google_project]}/zones/#{bootstrap_options[:zone_name]}/diskTypes/"
-            standard_disk_type = disk_type_prefix + 'pd-standard'
-            if bootstrap_options[:disk_type].nil?
-              bootstrap_options[:disk_type] = standard_disk_type
-            else
-              bootstrap_options[:disk_type] = disk_type_prefix + bootstrap_options[:disk_type]
-            end
+            standard_disk_type = disk_type_prefix + "pd-standard"
+            bootstrap_options[:disk_type] = if bootstrap_options[:disk_type].nil?
+                                              standard_disk_type
+                                            else
+                                              disk_type_prefix + bootstrap_options[:disk_type]
+                                            end
 
             if bootstrap_options[:disks].nil?
               # create the persistent boot disk
               disk_defaults = {
-                :name => machine_spec.name,
-                :size_gb => bootstrap_options[:disk_size],
-                :zone_name => bootstrap_options[:zone_name],
-                :source_image => bootstrap_options[:image_name],
-                :type => bootstrap_options[:disk_type],
+                name: machine_spec.name,
+                size_gb: bootstrap_options[:disk_size],
+                zone_name: bootstrap_options[:zone_name],
+                source_image: bootstrap_options[:image_name],
+                type: bootstrap_options[:disk_type]
               }
 
               disk = compute.disks.create(disk_defaults)
@@ -70,7 +64,7 @@ class Chef
 
           def destroy_machine(action_handler, machine_spec, machine_options)
             server = server_for(machine_spec)
-            if server && server.state != 'archive'
+            if server && server.state != "archive"
               action_handler.perform_action "destroy machine #{machine_spec.name} (#{machine_spec.location['server_id']} at #{driver_url})" do
                 server.destroy
               end
@@ -80,19 +74,18 @@ class Chef
             strategy.cleanup_convergence(action_handler, machine_spec)
           end
 
-          def self.compute_options_for(provider, id, config)
+          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_config = { driver_options: { compute_options: new_compute_options } }
             new_defaults = {
-              :driver_options  => { :compute_options => {} },
-              :machine_options => { :bootstrap_options => {}, :ssh_options => {} }
+              driver_options: { compute_options: {} },
+              machine_options: { bootstrap_options: {}, ssh_options: {} }
             }
             result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
 
-            [result, '']
+            [result, ""]
           end
-
         end
       end
     end

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

@@ -1,63 +1,61 @@
-require 'fog/joyent'
+require "fog/joyent"
 
 #   fog:Joyent:<joyent_url>
 class Chef
-module Provisioning
-module FogDriver
-  module Providers
-    class Joyent < FogDriver::Driver
-
-      Driver.register_provider_class('Joyent', FogDriver::Providers::Joyent)
-
-      def creator
-        compute_options[:joyent_username]
-      end
-
-      def bootstrap_options_for(machine_spec, machine_options)
-        bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
-
-        bootstrap_options[:tags] = default_tags(machine_spec, bootstrap_options[:tags] || {})
-
-        bootstrap_options[:tags].each do |key, val|
-          bootstrap_options["tag.#{key}"] = val
+  module Provisioning
+    module FogDriver
+      module Providers
+        class Joyent < FogDriver::Driver
+          Driver.register_provider_class("Joyent", FogDriver::Providers::Joyent)
+
+          def creator
+            compute_options[:joyent_username]
+          end
+
+          def bootstrap_options_for(machine_spec, machine_options)
+            bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
+
+            bootstrap_options[:tags] = default_tags(machine_spec, bootstrap_options[:tags] || {})
+
+            bootstrap_options[:tags].each do |key, val|
+              bootstrap_options["tag.#{key}"] = val
+            end
+
+            bootstrap_options[:name] ||= machine_spec.name
+
+            bootstrap_options
+          end
+
+          def find_floating_ips(_server, _action_handler)
+            []
+          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)
+
+            new_compute_options[:joyent_url] = id if id && id != ""
+            credential = Fog.credentials
+
+            new_compute_options[:joyent_username] ||= credential[:joyent_username]
+            new_compute_options[:joyent_password] ||= credential[:joyent_password]
+            new_compute_options[:joyent_keyname] ||= credential[:joyent_keyname]
+            new_compute_options[:joyent_keyfile] ||= credential[:joyent_keyfile]
+            new_compute_options[:joyent_url] ||= credential[:joyent_url]
+            new_compute_options[:joyent_version] ||= credential[:joyent_version]
+
+            id = result[:driver_options][:compute_options][:joyent_url]
+
+            [result, id]
+          end
         end
-
-        bootstrap_options[:name] ||= machine_spec.name
-
-        bootstrap_options
       end
-
-      def find_floating_ips(server, action_handler)
-        []
-      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)
-
-        new_compute_options[:joyent_url] = id if (id && id != '')
-        credential = Fog.credentials
-
-        new_compute_options[:joyent_username] ||= credential[:joyent_username]
-        new_compute_options[:joyent_password] ||= credential[:joyent_password]
-        new_compute_options[:joyent_keyname] ||= credential[:joyent_keyname]
-        new_compute_options[:joyent_keyfile] ||= credential[:joyent_keyfile]
-        new_compute_options[:joyent_url] ||= credential[:joyent_url]
-        new_compute_options[:joyent_version] ||= credential[:joyent_version]
-
-        id = result[:driver_options][:compute_options][:joyent_url]
-
-        [result, id]
-      end
-
     end
   end
 end
-end
-end

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

@@ -1,169 +1,162 @@
 # fog:OpenStack:https://identifyhost:portNumber/v2.0
 class Chef
-module Provisioning
-module FogDriver
-  module Providers
-    class OpenStack < FogDriver::Driver
-
-      Driver.register_provider_class('OpenStack', FogDriver::Providers::OpenStack)
-
-      def creator
-        compute_options[:openstack_username]
-      end
-
-      def convergence_strategy_for(machine_spec, machine_options)
-        machine_options = Cheffish::MergedConfig.new(machine_options, {
-                                                       :convergence_options => {:ohai_hints => {'openstack' => {}}}
-                                                     })
-        super(machine_spec, machine_options)
-      end
+  module Provisioning
+    module FogDriver
+      module Providers
+        class OpenStack < FogDriver::Driver
+          Driver.register_provider_class("OpenStack", FogDriver::Providers::OpenStack)
+
+          def creator
+            compute_options[:openstack_username]
+          end
 
-      def create_winrm_transport(machine_spec, machine_options, server)
-        if machine_options[:winrm].nil?
-          fail "You must provide winrm settings in machine_options to use the winrm transport!"
-        end
-        remote_host = determine_remote_host machine_spec, server
-        Chef::Log::info("Connecting to server #{remote_host}")
-        port = machine_options[:winrm][:port] || 5985
-        endpoint = "http://#{remote_host}:#{port}/wsman"
-        type = machine_options[:winrm][:type] || :negotiate
-        decrypted_password = machine_options[:winrm][:password] || ''
-        options = {
-            :user => machine_options[:winrm][:username] || 'Administrator',
-            :pass => decrypted_password,
-            :disable_sspi => !!machine_options[:winrm][:disable_sspi] || false,
-            :basic_auth_only => !!machine_options[:winrm][:basic_auth_only] || false
-        }
-        Chef::Provisioning::Transport::WinRM.new(endpoint, type, options, {})
-      end
+          def convergence_strategy_for(machine_spec, machine_options)
+            machine_options = Cheffish::MergedConfig.new(machine_options,
+                                                         convergence_options: { ohai_hints: { "openstack" => {} } })
+            super(machine_spec, machine_options)
+          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 create_winrm_transport(machine_spec, machine_options, server)
+            if machine_options[:winrm].nil?
+              raise "You must provide winrm settings in machine_options to use the winrm transport!"
+            end
+            remote_host = determine_remote_host machine_spec, server
+            Chef::Log.info("Connecting to server #{remote_host}")
+            port = machine_options[:winrm][:port] || 5985
+            endpoint = "http://#{remote_host}:#{port}/wsman"
+            type = machine_options[:winrm][:type] || :negotiate
+            decrypted_password = machine_options[:winrm][:password] || ""
+            options = {
+              user: machine_options[:winrm][:username] || "Administrator",
+              pass: decrypted_password,
+              disable_sspi: !!machine_options[:winrm][:disable_sspi] || false,
+              basic_auth_only: !!machine_options[:winrm][:basic_auth_only] || false
+            }
+            Chef::Provisioning::Transport::WinRM.new(endpoint, type, options, {})
+          end
 
-        new_compute_options[:openstack_auth_url] = id if (id && id != '')
+          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)
 
-        credential = Fog.credentials.find_all{ |k,v|
-          k.to_s.start_with?('openstack') }
-        credential.each { |k,v|
-          new_compute_options[k] ||= v
-        }
+            new_compute_options[:openstack_auth_url] = id if id && id != ""
 
-        id = result[:driver_options][:compute_options][:openstack_auth_url]
+            credential = Fog.credentials.find_all do |k, _v|
+              k.to_s.start_with?("openstack")
+            end
+            credential.each do |k, v|
+              new_compute_options[k] ||= v
+            end
 
-        [result, id]
-      end
+            id = result[:driver_options][:compute_options][:openstack_auth_url]
 
-      # Image methods
-      def allocate_image(action_handler, image_spec, image_options, machine_spec, machine_options)
-        image = image_for(image_spec)
-        if image
-          raise "The image already exists, why are you asking me to create it?  I can't do that, Dave."
-        end
-        action_handler.perform_action "Create image #{image_spec.name} from machine #{machine_spec.name} with options #{image_options.inspect}" do
-          response = compute.create_image(
-            machine_spec.reference['server_id'], image_spec.name,
-            {
-              description: "The Image named '#{image_spec.name}"
-            })
-
-          image_spec.reference = {
-            driver_url: driver_url,
-            driver_version: FogDriver::VERSION,
-            image_id: response.body['image']['id'],
-            creator: creator,
-            allocated_it: Time.new.to_i
-          }
-        end
-      end
+            [result, id]
+          end
 
-      def ready_image(action_handler, image_spec, image_options)
-        actual_image = image_for(image_spec)
-        if actual_image.nil?
-          raise 'Cannot ready an image that does not exist'
-        else
-          if actual_image.status != 'ACTIVE'
-            action_handler.report_progress 'Waiting for image to be active ...'
-            wait_until_ready_image(action_handler, image_spec, actual_image)
-          else
-            action_handler.report_progress "Image #{image_spec.name} is active!"
+          # Image methods
+          def allocate_image(action_handler, image_spec, image_options, machine_spec, _machine_options)
+            image = image_for(image_spec)
+            if image
+              raise "The image already exists, why are you asking me to create it?  I can't do that, Dave."
+            end
+            action_handler.perform_action "Create image #{image_spec.name} from machine #{machine_spec.name} with options #{image_options.inspect}" do
+              response = compute.create_image(
+                machine_spec.reference["server_id"], image_spec.name,
+                description: "The Image named '#{image_spec.name}"
+              )
+
+              image_spec.reference = {
+                driver_url: driver_url,
+                driver_version: FogDriver::VERSION,
+                image_id: response.body["image"]["id"],
+                creator: creator,
+                allocated_it: Time.new.to_i
+              }
+            end
           end
-        end
-      end
 
-      def destroy_image(action_handler, image_spec, image_options)
-        image = image_for(image_spec)
-        unless image.status == "DELETED"
-          image.destroy
-        end
-      end
+          def ready_image(action_handler, image_spec, _image_options)
+            actual_image = image_for(image_spec)
+            if actual_image.nil?
+              raise "Cannot ready an image that does not exist"
+            else
+              if actual_image.status != "ACTIVE"
+                action_handler.report_progress "Waiting for image to be active ..."
+                wait_until_ready_image(action_handler, image_spec, actual_image)
+              else
+                action_handler.report_progress "Image #{image_spec.name} is active!"
+              end
+            end
+          end
 
-      def wait_until_ready_image(action_handler, image_spec, image=nil)
-        wait_until_image(action_handler, image_spec, image) { image.status == 'ACTIVE' }
-      end
+          def destroy_image(_action_handler, image_spec, _image_options)
+            image = image_for(image_spec)
+            image.destroy unless image.status == "DELETED"
+          end
 
-      def wait_until_image(action_handler, image_spec, image=nil, &block)
-        image ||= image_for(image_spec)
-        time_elapsed = 0
-        sleep_time = 10
-        max_wait_time = 300
-        if !yield(image)
-          action_handler.report_progress "waiting for image #{image_spec.name} (#{image.id} on #{driver_url}) to be active ..."
-          while time_elapsed < max_wait_time && !yield(image)
-           action_handler.report_progress "been waiting #{time_elapsed}/#{max_wait_time} -- sleeping #{sleep_time} seconds for image #{image_spec.name} (#{image.id} on #{driver_url}) to be ACTIVE instead of #{image.status}..."
-           sleep(sleep_time)
-           image.reload
-           time_elapsed += sleep_time
+          def wait_until_ready_image(action_handler, image_spec, image = nil)
+            wait_until_image(action_handler, image_spec, image) { image.status == "ACTIVE" }
           end
-          unless yield(image)
-            raise "Image #{image.id} did not become ready within #{max_wait_time} seconds"
+
+          def wait_until_image(action_handler, image_spec, image = nil)
+            image ||= image_for(image_spec)
+            time_elapsed = 0
+            sleep_time = 10
+            max_wait_time = 300
+            unless yield(image)
+              action_handler.report_progress "waiting for image #{image_spec.name} (#{image.id} on #{driver_url}) to be active ..."
+              while time_elapsed < max_wait_time && !yield(image)
+                action_handler.report_progress "been waiting #{time_elapsed}/#{max_wait_time} -- sleeping #{sleep_time} seconds for image #{image_spec.name} (#{image.id} on #{driver_url}) to be ACTIVE instead of #{image.status}..."
+                sleep(sleep_time)
+                image.reload
+                time_elapsed += sleep_time
+              end
+              unless yield(image)
+                raise "Image #{image.id} did not become ready within #{max_wait_time} seconds"
+              end
+              action_handler.report_progress "Image #{image_spec.name} is now ready"
+            end
           end
-          action_handler.report_progress "Image #{image_spec.name} is now ready"
-        end
-      end
 
-      def image_for(image_spec)
-        if image_spec.reference
-          compute.images.get(image_spec.reference[:image_id]) || compute.images.get(image_spec.reference['image_id'])
-        else
-          nil
-        end
-      end
+          def image_for(image_spec)
+            if image_spec.reference
+              compute.images.get(image_spec.reference[:image_id]) || compute.images.get(image_spec.reference["image_id"])
+            end
+          end
 
-      def determine_remote_host(machine_spec, server)
-        transport_address_location = (machine_spec.reference['transport_address_location'] || :none).to_sym
-
-        if machine_spec.reference['use_private_ip_for_ssh']
-          # The machine_spec has the old config key, lets update it - a successful chef converge will save the machine_spec
-          # TODO in 2.0 get rid of this update
-          machine_spec.reference.delete('use_private_ip_for_ssh')
-          machine_spec.reference['transport_address_location'] = :private_ip
-          server.private_ip_address
-        elsif transport_address_location == :ip_addresses
-          server.ip_addresses.first
-        elsif transport_address_location == :private_ip
-          server.private_ip_address
-        elsif transport_address_location == :public_ip
-          server.public_ip_address
-        elsif !server.public_ip_address && server.private_ip_address
-          Chef::Log.warn("Server #{machine_spec.name} has no public floating_ip address.  Using private floating_ip '#{server.private_ip_address}'.  Set driver option 'transport_address_location' => :private_ip if this will always be the case ...")
-          server.private_ip_address
-        elsif server.public_ip_address
-          server.public_ip_address
-        else
-          raise "Server #{server.id} has no private or public IP address!"
-          # raise "Invalid 'transport_address_location'.  They can only be 'public_ip', 'private_ip', or 'ip_addresses'."
+          def determine_remote_host(machine_spec, server)
+            transport_address_location = (machine_spec.reference["transport_address_location"] || :none).to_sym
+
+            if machine_spec.reference["use_private_ip_for_ssh"]
+              # The machine_spec has the old config key, lets update it - a successful chef converge will save the machine_spec
+              # TODO in 2.0 get rid of this update
+              machine_spec.reference.delete("use_private_ip_for_ssh")
+              machine_spec.reference["transport_address_location"] = :private_ip
+              server.private_ip_address
+            elsif transport_address_location == :ip_addresses
+              server.ip_addresses.first
+            elsif transport_address_location == :private_ip
+              server.private_ip_address
+            elsif transport_address_location == :public_ip
+              server.public_ip_address
+            elsif !server.public_ip_address && server.private_ip_address
+              Chef::Log.warn("Server #{machine_spec.name} has no public floating_ip address.  Using private floating_ip '#{server.private_ip_address}'.  Set driver option 'transport_address_location' => :private_ip if this will always be the case ...")
+              server.private_ip_address
+            elsif server.public_ip_address
+              server.public_ip_address
+            else
+              raise "Server #{server.id} has no private or public IP address!"
+              # raise "Invalid 'transport_address_location'.  They can only be 'public_ip', 'private_ip', or 'ip_addresses'."
+            end
+          end
         end
       end
-
     end
   end
 end
-end
-end