chef-provisioning-fog 0.26.1 → 0.26.3

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

@@ -1,7 +1,7 @@
-require 'base64'
-require 'uri'
-require 'fog/softlayer'
-require 'fog/softlayer/models/compute/server'
+require "base64"
+require "uri"
+require "fog/softlayer"
+require "fog/softlayer/models/compute/server"
 
 # fog:SoftLayer:<datacenter>
 class Chef
@@ -9,32 +9,31 @@ class Chef
     module FogDriver
       module Providers
         class SoftLayer < FogDriver::Driver
-          Driver.register_provider_class('SoftLayer', FogDriver::Providers::SoftLayer)
+          Driver.register_provider_class("SoftLayer", FogDriver::Providers::SoftLayer)
 
-          POST_SCRIPT_DONE = 'post-script-done'
+          POST_SCRIPT_DONE = "post-script-done".freeze
 
           def creator
             compute_options[:softlayer_username]
           end
 
           def convergence_strategy_for(machine_spec, machine_options)
-            machine_options = Cheffish::MergedConfig.new(machine_options, {
-                                                           :convergence_options => {:ohai_hints => {'softlayer' => {}}}
-                                                         })
+            machine_options = Cheffish::MergedConfig.new(machine_options,
+                                                         convergence_options: { ohai_hints: { "softlayer" => {} } })
             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_config = { driver_options: { compute_options: new_compute_options } }
             new_defaults = {
-              :driver_options => { :compute_options => Fog.credentials },
-              :machine_options => { :bootstrap_options => {} }
+              driver_options: { compute_options: Fog.credentials },
+              machine_options: { bootstrap_options: {} }
             }
             result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
-            id ||= ''
-            new_defaults[:machine_options][:bootstrap_options][:datacenter] = id if not id.empty?
+            id ||= ""
+            new_defaults[:machine_options][:bootstrap_options][:datacenter] = id unless id.empty?
 
             [result, id]
           end
@@ -65,45 +64,43 @@ class Chef
             # options
             opts.delete(:vlan) if opts[:vlan] && opts[:private_network_only]
 
-            opts.keep_if do |opt, val|
+            opts.keep_if do |opt, _val|
               ::Fog::Compute::Softlayer::Server.attributes.include?(opt) || opt =~ /private_vlan|vlan/
             end
             # fog-softlayer defines :tags but SoftLayer_Hardware_Server rejects it...
-            #opts.delete :tags
+            # opts.delete :tags
 
             # we hook in our own post-install script which uses userMetadata to
             # tell us when post-install is complete. If the user supplies their
             # own script it will be called by our hook before indicating
             # completion in userData.
-            opts[:postInstallScriptUri] = 'https://dal05.objectstorage.service.networklayer.com/v1/AUTH_b1b23a05-1c03-4961-8b08-2339886e476f/dist/sl-post-hook.sh'
+            opts[:postInstallScriptUri] = "https://dal05.objectstorage.service.networklayer.com/v1/AUTH_b1b23a05-1c03-4961-8b08-2339886e476f/dist/sl-post-hook.sh"
 
             super(num_servers, opts, parallelizer)
           end
 
-          def find_floating_ips(server, action_handler)
+          def find_floating_ips(_server, _action_handler)
             []
           end
 
           def server_for(machine_spec)
-              if machine_spec.reference
-                  id = machine_spec.reference['server_id']
-                  if id and 0 != id
-                    compute.servers.get(id)
-                  else
-                    sv = compute.servers.new(
-                      :uid => machine_spec.reference['uid'],
-                      :name => machine_spec.name,
-                      :domain => machine_spec.reference['domain']
-                    )
-
-                    Chef::Log.info("waiting for server.id")
-                    sv.wait_for_id
-                    machine_spec.reference['server_id'] = sv.id
-                    return sv
-                  end
+            if machine_spec.reference
+              id = machine_spec.reference["server_id"]
+              if id && (id != 0)
+                compute.servers.get(id)
               else
-                  nil
+                sv = compute.servers.new(
+                  uid: machine_spec.reference["uid"],
+                  name: machine_spec.name,
+                  domain: machine_spec.reference["domain"]
+                )
+
+                Chef::Log.info("waiting for server.id")
+                sv.wait_for_id
+                machine_spec.reference["server_id"] = sv.id
+                return sv
               end
+            end
           end
 
           def servers_for(specs_and_options)
@@ -117,45 +114,45 @@ class Chef
 
           def create_servers(action_handler, specs_and_options, parallelizer, &block)
             super do |machine_spec, server|
-              machine_spec.reference['uid'] = server.uid
-              machine_spec.reference['domain'] = server.domain
+              machine_spec.reference["uid"] = server.uid
+              machine_spec.reference["domain"] = server.domain
               machine_spec.save(action_handler)
               bootstrap_options = specs_and_options[machine_spec][:bootstrap_options]
               create_timeout = bootstrap_options[:create_timeout] || 3600
               wait_for_id(action_handler, server, create_timeout)
               set_post_install_info(action_handler, server, bootstrap_options)
 
-              block.call(machine_spec, server) if block
+              yield(machine_spec, server) if block
             end
           end
 
           def request(server, path, **options)
-              service = server.bare_metal? ? :hardware_server : :virtual_guest
-              server.service.request(service, path, options)
+            service = server.bare_metal? ? :hardware_server : :virtual_guest
+            server.service.request(service, path, options)
           end
 
           def set_post_install_info(action_handler, server, bootstrap_options)
-            existing_user_data = request(server, server.id, :query => {:objectMask => 'userData'}).body['userData']
+            existing_user_data = request(server, server.id, query: { objectMask: "userData" }).body["userData"]
             Chef::Log.info("userData from SLAPI is #{existing_user_data.inspect}")
             if existing_user_data.is_a? Array
-              if existing_user_data.size < 1
-                existing_user_data = ''
-              else
-                existing_user_data = existing_user_data.first.fetch('value', '')
-              end
+              existing_user_data = if existing_user_data.empty?
+                                     ""
+                                   else
+                                     existing_user_data.first.fetch("value", "")
+                                   end
             end
             Chef::Log.info("userData after processing is #{existing_user_data.inspect}")
             # VSI userData is empty; bare metal userData will be an Array
             if existing_user_data.empty?
               action_handler.report_progress("Setting userData to detect post install status.")
-              sl_user = compute.instance_variable_get '@softlayer_username'
-              sl_key = compute.instance_variable_get '@softlayer_api_key'
-              service = server.bare_metal? ? 'Hardware_Server' : 'Virtual_Guest'
-              ::Retryable.retryable(:tries => 60, :sleep => 5) do
+              sl_user = compute.instance_variable_get "@softlayer_username"
+              sl_key = compute.instance_variable_get "@softlayer_api_key"
+              service = server.bare_metal? ? "Hardware_Server" : "Virtual_Guest"
+              ::Retryable.retryable(tries: 60, sleep: 5) do
                 update_url = URI::HTTPS.build(
-                  :userinfo => "#{sl_user}:#{sl_key}",
-                  :host => 'api.service.softlayer.com',
-                  :path => "/rest/v3/SoftLayer_#{service}/#{server.id}/setUserMetadata",
+                  userinfo: "#{sl_user}:#{sl_key}",
+                  host: "api.service.softlayer.com",
+                  path: "/rest/v3/SoftLayer_#{service}/#{server.id}/setUserMetadata"
                 ).to_s
 
                 post_install_info = <<SHELL
@@ -170,26 +167,26 @@ SHELL
                 res = request(
                   server,
                   "#{server.id}/setUserMetadata",
-                  :http_method => 'POST', :body => [
+                  http_method: "POST", body: [
                     [
-                        encoded_info
+                      encoded_info
                     ]
                   ]
                 )
 
-                raise "Failed to setUserMetadata" unless TrueClass == res.body.class or res.body.first['value']
+                raise "Failed to setUserMetadata" unless (TrueClass == res.body.class) || res.body.first["value"]
               end
             end
           end
 
           def wait_for_id(action_handler, server, create_timeout)
-            return if 0 != server.id
+            return if server.id != 0
 
             # Cannot use Fog.wait_for because it requires server.id which is
             # not initially available for bare metal.
             server.wait_for_id(create_timeout) do |srv_info|
-                srv_id = srv_info ? srv_info['id'] : 'not set yet'
-                action_handler.report_progress "waiting for server.id on #{server.name} (#{server.uid}): #{srv_id} #{srv_info}"
+              srv_id = srv_info ? srv_info["id"] : "not set yet"
+              action_handler.report_progress "waiting for server.id on #{server.name} (#{server.uid}): #{srv_id} #{srv_info}"
             end
           end
 
@@ -198,11 +195,11 @@ SHELL
 
             action_handler.report_progress "waiting for post-install script on #{server.name} to finish"
 
-            ::Retryable.retryable(:tries => 600, :sleep => 2) do
+            ::Retryable.retryable(tries: 600, sleep: 2) do
               action_handler.report_progress "checking post-install status on #{server.name}"
-              res = request(server, server.id, :query => 'objectMask=userData')
-              userData = res.body['userData']
-              value = userData.first['value']
+              res = request(server, server.id, query: "objectMask=userData")
+              userData = res.body["userData"]
+              value = userData.first["value"]
 
               raise "Waiting for post-install script" unless POST_SCRIPT_DONE == value
             end
@@ -211,7 +208,7 @@ SHELL
           end
 
           def start_server(action_handler, machine_spec, server)
-            ::Retryable.retryable(:tries => 10, :sleep => 2) do
+            ::Retryable.retryable(tries: 10, sleep: 2) do
               super
             end
           end

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

@@ -4,7 +4,7 @@ class Chef
     module FogDriver
       module Providers
         class Vcair < FogDriver::Driver
-          Driver.register_provider_class('vcair', FogDriver::Providers::Vcair)
+          Driver.register_provider_class("vcair", FogDriver::Providers::Vcair)
 
           def creator
             driver_options[:username]
@@ -13,12 +13,12 @@ class Chef
           def initialize(driver_url, config)
             super(driver_url, config)
 
-            @auth_params = {provider: 'vclouddirector'}
-            _fog, _vcair, @auth_params[:vcloud_director_host] = driver_url.split(':', 3)
+            @auth_params = { provider: "vclouddirector" }
+            _fog, _vcair, @auth_params[:vcloud_director_host] = driver_url.split(":", 3)
             @auth_params[:vcloud_director_username] = "#{driver_options[:username]}@#{driver_options[:org]}"
             @auth_params[:vcloud_director_password] = driver_options[:password]
             @auth_params[:vcloud_director_show_progress] = driver_options[:show_progress] || false
-            Chef::Log.debug('Initialized driver for vcair')
+            Chef::Log.debug("Initialized driver for vcair")
           end
 
           def compute
@@ -37,44 +37,43 @@ class Chef
 
           # Overrides the parent method and adds some additional vCloud specific metadata
           def create_servers(action_handler, specs_and_options, parallelizer, &block)
-
             specs_and_options.each do |machine_spec, machine_options|
               machine_spec.reference ||= {}
               # Add some vCloud info to the machine_spec
               bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
-              machine_spec.reference['vdc'] = vdc(bootstrap_options).name
-              machine_spec.reference['net'] = net(bootstrap_options).name
+              machine_spec.reference["vdc"] = vdc(bootstrap_options).name
+              machine_spec.reference["net"] = net(bootstrap_options).name
 
               # Save the key and whether we're using sudo
-              machine_spec.reference['key_name'] = bootstrap_options[:key_name] if bootstrap_options.has_key?(:key_name)
-              machine_spec.reference['sudo'] = bootstrap_options[:sudo] if bootstrap_options.has_key?(:sudo)
+              machine_spec.reference["key_name"] = bootstrap_options[:key_name] if bootstrap_options.key?(:key_name)
+              machine_spec.reference["sudo"] = bootstrap_options[:sudo] if bootstrap_options.key?(:sudo)
             end
 
             super
           end
 
           def create_many_servers(num_servers, bootstrap_options, parallelizer)
-            parallelizer.parallelize(1.upto(num_servers)) do |i|
+            parallelizer.parallelize(1.upto(num_servers)) do |_i|
               clean_bootstrap_options = Marshal.load(Marshal.dump(bootstrap_options)) # Prevent destructive operations on bootstrap_options.
-              vm=nil
+              vm = nil
               begin
                 begin
-                  Chef::Log.debug('Creating vApp...')
+                  Chef::Log.debug("Creating vApp...")
                   instantiate(clean_bootstrap_options)
-                  Chef::Log.debug('Created vApp')
+                  Chef::Log.debug("Created vApp")
                 rescue Fog::Errors::Error => e
                   unless e.minor_error_code == "DUPLICATE_NAME"
                     # if it's already there, just use the current one
                     raise e
                   end
-                  Chef::Log.warn('Found existing vApp with the same name!')
+                  Chef::Log.warn("Found existing vApp with the same name!")
                 end
                 vdc = vdc(clean_bootstrap_options)
 
                 Chef::Log.debug("Searching for #{bootstrap_options[:name]}...")
                 vapp = vdc.vapps.get_by_name(clean_bootstrap_options[:name])
                 raise "Couldn't find vApp #{bootstrap_options[:name]} that was just created!" if vapp.nil?
-                vm = vapp.vms.find {|v| v.vapp_name == clean_bootstrap_options[:name]}
+                vm = vapp.vms.find { |v| v.vapp_name == clean_bootstrap_options[:name] }
                 raise "No VMs found in vApp!" if vm.nil?
                 Chef::Log.debug("Found #{vm.name}")
                 update_customization(clean_bootstrap_options, vm)
@@ -89,10 +88,9 @@ class Chef
                 Chef::Log.debug("Updating network for #{vm.name}...")
                 update_network(clean_bootstrap_options, vapp, vm)
                 Chef::Log.debug("Updated network for #{vm.name}")
-
               rescue Excon::Errors::BadRequest => e
                 response = Chef::JSONCompat.from_json(e.response.body)
-                if response['badRequest']['code'] == 400
+                if response["badRequest"]["code"] == 400
                   message = "Bad request (400): #{response['badRequest']['message']}"
                   Chef::Log.error(message)
                 else
@@ -106,47 +104,41 @@ class Chef
 
               yield vm if block_given?
               vm
-
             end.to_a
           end
 
-
           def start_server(action_handler, machine_spec, server)
-
             # If it is stopping, wait for it to get out of "stopping" transition state before starting
-            if server.status == 'stopping'
+            if server.status == "stopping"
               action_handler.report_progress "wait for #{machine_spec.name} (#{server.id} on #{driver_url}) to finish stopping ..."
               # vCloud Air
               # NOTE: vCloud Air Fog does not get server.status via http every time
-              server.wait_for { server.reload ; server.status != 'stopping' }
+              server.wait_for { server.reload; server.status != "stopping" }
               action_handler.report_progress "#{machine_spec.name} is now stopped"
             end
 
             # NOTE: vCloud Air Fog does not get server.status via http every time
             server.reload
 
-            if server.status == 'off' || server.status != 'on'
+            if server.status == "off" || server.status != "on"
               action_handler.perform_action "start machine #{machine_spec.name} (#{server.id} on #{driver_url})" do
                 server.power_on
-                machine_spec.reference['started_at'] = Time.now.to_i
+                machine_spec.reference["started_at"] = Time.now.to_i
               end
               machine_spec.save(action_handler)
             end
           end
 
-
           def server_for(machine_spec)
             if machine_spec.reference
               Chef::Log.debug("Checking for VDC #{machine_spec.reference['vdc']}...")
-              vapp = org.vdcs.get_by_name(machine_spec.reference['vdc']).vapps.get_by_name(machine_spec.name)
+              vapp = org.vdcs.get_by_name(machine_spec.reference["vdc"]).vapps.get_by_name(machine_spec.name)
 
               server = unless vapp.nil?
                          unless vapp.vms.first.nil?
-                           vapp.vms.find{|vm| vm.id == machine_spec.reference['server_id'] }
+                           vapp.vms.find { |vm| vm.id == machine_spec.reference["server_id"] }
                          end
                        end
-            else
-              nil
             end
           end
 
@@ -168,24 +160,24 @@ class Chef
 
           def create_ssh_transport(machine_spec, machine_options, server)
             ssh_options = ssh_options_for(machine_spec, machine_options, server)
-            username = machine_spec.reference['ssh_username'] || default_ssh_username
+            username = machine_spec.reference["ssh_username"] || default_ssh_username
             options = {}
-            if machine_spec.reference[:sudo] || (!machine_spec.reference.has_key?(:sudo) && username != 'root')
-              options[:prefix] = 'sudo '
+            if machine_spec.reference[:sudo] || (!machine_spec.reference.key?(:sudo) && username != "root")
+              options[:prefix] = "sudo "
             end
 
             remote_host = nil
             # vCloud Air networking is funky
-            #if machine_options[:use_private_ip_for_ssh] # vCloud Air probably needs private ip for now
+            # if machine_options[:use_private_ip_for_ssh] # vCloud Air probably needs private ip for now
             if server.ip_address
               remote_host = server.ip_address
             else
               raise "Server #{server.id} has no private or public IP address!"
             end
 
-            #Enable pty by default
+            # Enable pty by default
             options[:ssh_pty_enable] = true
-            options[:ssh_gateway] = machine_spec.reference['ssh_gateway'] if machine_spec.reference.has_key?('ssh_gateway')
+            options[:ssh_gateway] = machine_spec.reference["ssh_gateway"] if machine_spec.reference.key?("ssh_gateway")
 
             Transport::SSH.new(remote_host, username, ssh_options, options, config)
           end
@@ -204,13 +196,13 @@ class Chef
             # vCloud Air is funky for network.  VM has to be powered off or you get this error:
             #    Primary NIC cannot be changed when the VM is not in Powered-off state
             # See code in update_network()
-            #DISABLED: converge_floating_ips(action_handler, machine_spec, machine_options, server)
+            # DISABLED: converge_floating_ips(action_handler, machine_spec, machine_options, server)
 
             begin
               wait_for_transport(action_handler, machine_spec, machine_options, server)
             rescue Fog::Errors::TimeoutError
               # Only ever reboot once, and only if it's been less than 10 minutes since we stopped waiting
-              if machine_spec.reference['started_at'] || remaining_wait_time(machine_spec, machine_options) < -(10*60)
+              if machine_spec.reference["started_at"] || remaining_wait_time(machine_spec, machine_options) < -(10 * 60)
                 raise
               else
                 # Sometimes (on EC2) the machine comes up but gets stuck or has
@@ -236,7 +228,7 @@ class Chef
               raise "VDC #{bootstrap_options[:vdc]} not found" unless @vdc
             else
               @vdc ||= org.vdcs.first
-              raise 'No VDC found' unless @vdc
+              raise "No VDC found" unless @vdc
             end
 
             Chef::Log.debug("VDC set to #{@vdc.name}")
@@ -249,8 +241,8 @@ class Chef
               raise "Network #{bootstrap_options[:net]} not found" unless @net
             else
               # Grab first non-isolated (bridged, natRouted) network
-              @net ||= org.networks.find { |n| n if !n.fence_mode.match("isolated") }
-              raise 'No non-isolated network found' unless @net
+              @net ||= org.networks.find { |n| n unless n.fence_mode.match("isolated") }
+              raise "No non-isolated network found" unless @net
             end
 
             Chef::Log.debug("Network set to #{@net.name}")
@@ -261,9 +253,9 @@ class Chef
             # If we specify a catalog name, search for the image in it,
             # otherwise return the first image we find in any catalog.
             if bootstrap_options[:catalog_name].nil?
-              #TODO: maybe make a hash for caching
+              # TODO: maybe make a hash for caching
               org.catalogs.map do |cat|
-                #cat.catalog_items.get_by_name(config_value(:image))
+                # cat.catalog_items.get_by_name(config_value(:image))
                 cat.catalog_items.get_by_name(bootstrap_options[:image_name])
               end.compact.first
             else
@@ -274,7 +266,7 @@ class Chef
           end
 
           def instantiate(bootstrap_options)
-            #node_name = config_value(:chef_node_name)
+            # node_name = config_value(:chef_node_name)
             node_name = bootstrap_options[:name]
             vdc = vdc(bootstrap_options)
             net = net(bootstrap_options)
@@ -283,8 +275,9 @@ class Chef
               node_name,
               vdc_id: vdc.id,
               network_id: net.id,
-              description: "id:#{node_name}")
-            #rescue CloudExceptions::ServerCreateError => e
+              description: "id:#{node_name}"
+            )
+            # rescue CloudExceptions::ServerCreateError => e
           end
 
           # Create a WinRM transport for a vCloud Air Vapp VM instance
@@ -293,7 +286,7 @@ class Chef
           # @param [Fog::Compute::Server] server A Fog mapping to the AWS instance
           # @return [ChefMetal::Transport::WinRM] A WinRM Transport object to talk to the server
           def create_winrm_transport(machine_spec, machine_options, server)
-            port = machine_spec.reference['winrm_port'] || 5985
+            port = machine_spec.reference["winrm_port"] || 5985
             endpoint = "http://#{server.ip_address}:#{port}/wsman"
             type = :plaintext
 
@@ -301,10 +294,10 @@ class Chef
             # are using
             # TODO: Improve that and support different users
             options = {
-              :user => 'Administrator',
-              :pass => machine_options[:winrm_options][:password],
-              :disable_sspi => true,
-              :basic_auth_only => true
+              user: "Administrator",
+              pass: machine_options[:winrm_options][:password],
+              disable_sspi: true,
+              basic_auth_only: true
             }
             Chef::Provisioning::Transport::WinRM.new(endpoint, type, options, {})
           end
@@ -312,32 +305,32 @@ class Chef
           def update_customization(bootstrap_options, server)
             Chef::Log.debug("Customizing vApp: #{server.name}")
             ## Initialization before first power on.
-            custom=server.customization
+            custom = server.customization
 
             if bootstrap_options[:customization_script]
               custom.script = open(bootstrap_options[:customization_script]).read
             end
 
             bootstrap_options[:protocol] ||= case server.operating_system
-                                         when /Windows/
-                                           'winrm'
-                                         else
-                                           'ssh'
+                                             when /Windows/
+                                               "winrm"
+                                             else
+                                               "ssh"
                                          end
             password = case bootstrap_options[:protocol]
-                       when 'ssh'
+                       when "ssh"
                          bootstrap_options[:ssh_options][:password] unless bootstrap_options[:ssh_options].nil?
-                       when 'winrm'
+                       when "winrm"
                          bootstrap_options[:winrm_options][:password] unless bootstrap_options[:winrm_options].nil?
                        end
 
             if password
-              custom.admin_password =  password
+              custom.admin_password = password
               custom.admin_password_auto = false
               custom.reset_password_required = false
             else
               # Password will be autogenerated
-              custom.admin_password_auto=true
+              custom.admin_password_auto = true
               # API will force password resets when auto is enabled
               custom.reset_password_required = true
             end
@@ -350,7 +343,7 @@ class Chef
             # Windows can only handle 15 character hostnames
             custom.computer_name = case server.operating_system
                                    when /Windows/
-                                     bootstrap_options[:name].gsub(/\W/,"-").slice(0..14)
+                                     bootstrap_options[:name].gsub(/\W/, "-").slice(0..14)
                                    else
                                      bootstrap_options[:name]
                                    end
@@ -368,16 +361,16 @@ class Chef
             # Define network connection for vm based on existing routed network
 
             # vCloud Air inlining vapp() and vm()
-            #vapp = vdc.vapps.get_by_name(bootstrap_options[:name])
-            #vm = vapp.vms.find {|v| v.vapp_name == bootstrap_options[:name]}
+            # vapp = vdc.vapps.get_by_name(bootstrap_options[:name])
+            # vm = vapp.vms.find {|v| v.vapp_name == bootstrap_options[:name]}
             return if vm.ip_address != "" # return if ip address is set, as this isn't a new VM
-            Chef::Log.debug('No IP address found.  Must be a new VM.')
+            Chef::Log.debug("No IP address found.  Must be a new VM.")
             net = net(bootstrap_options)
             Chef::Log.debug("Searching for network: #{net.name}")
             nc = vapp.network_config.find { |netc| netc if netc[:networkName].match(net.name) }
             Chef::Log.debug("Found network configuration: #{nc}")
             networks_config = [nc]
-            section = {PrimaryNetworkConnectionIndex: 0}
+            section = { PrimaryNetworkConnectionIndex: 0 }
             section[:NetworkConnection] = networks_config.compact.each_with_index.map do |network, i|
               connection = {
                 network: network[:networkName],
@@ -387,12 +380,12 @@ class Chef
               }
               ip_address      = network[:ip_address]
               ## TODO: support config options for allocation mode
-              #allocation_mode = network[:allocation_mode]
-              #allocation_mode = 'manual' if ip_address
-              #allocation_mode = 'dhcp' unless %w{dhcp manual pool}.include?(allocation_mode)
-              #allocation_mode = 'POOL'
-              #connection[:Dns1] = dns1 if dns1
-              allocation_mode = 'pool'
+              # allocation_mode = network[:allocation_mode]
+              # allocation_mode = 'manual' if ip_address
+              # allocation_mode = 'dhcp' unless %w{dhcp manual pool}.include?(allocation_mode)
+              # allocation_mode = 'POOL'
+              # connection[:Dns1] = dns1 if dns1
+              allocation_mode = "pool"
               connection[:IpAddressAllocationMode] = allocation_mode.upcase
               connection[:IpAddress] = ip_address if ip_address
               connection
@@ -400,7 +393,8 @@ class Chef
 
             ## attach the network to the vm
             nc_task = compute.put_network_connection_system_section_vapp(
-              vm.id,section).body
+              vm.id, section
+            ).body
             compute.process_task(nc_task)
           end
 
@@ -416,9 +410,9 @@ class Chef
             Chef::Log.info("Destroying machine #{machine_spec.name}...")
             bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
             vdc = vdc(bootstrap_options)
-            if server && server.status != 'archive' # TODO: does vCloud Air do archive?
+            if server && server.status != "archive" # TODO: does vCloud Air do archive?
               action_handler.perform_action "destroy machine #{machine_spec.name} (#{machine_spec.reference['server_id']} at #{driver_url})" do
-                #NOTE: currently doing 1 vm for 1 vapp
+                # NOTE: currently doing 1 vm for 1 vapp
                 vapp = vdc.vapps.get_by_name(machine_spec.name)
                 if vapp
                   Chef::Log.debug("Found vApp #{machine_spec.name}")
@@ -435,13 +429,13 @@ 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] = 'vclouddirector'
-            new_config = { :driver_options => { :compute_options => new_compute_options }}
+            new_compute_options[:provider] = "vclouddirector"
+            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)