knife-rackspace 0.11.0 → 1.0.0

data/lib/chef/knife/rackspace_flavor_list.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Seth Chisamore (<schisamo@opscode.com>)
-# Copyright:: Copyright (c) 2011-2012 Opscode, Inc.
+# Author:: Seth Chisamore (<schisamo@chef.io>)
+# Copyright:: Copyright (c) 2011-2016 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require 'chef/knife/rackspace_base'
+require "chef/knife/rackspace_base"
 
 class Chef
   class Knife
@@ -29,32 +29,32 @@ class Chef
       def run
         if version_one?
           flavor_list = [
-            ui.color('ID', :bold),
-            ui.color('Name', :bold),
-            ui.color('Architecture', :bold),
-            ui.color('RAM', :bold),
-            ui.color('Disk', :bold)
+            ui.color("ID", :bold),
+            ui.color("Name", :bold),
+            ui.color("Architecture", :bold),
+            ui.color("RAM", :bold),
+            ui.color("Disk", :bold),
           ]
         else
           flavor_list = [
-            ui.color('ID', :bold),
-            ui.color('Name', :bold),
-            ui.color('VCPUs', :bold),
-            ui.color('RAM', :bold),
-            ui.color('Disk', :bold)
+            ui.color("ID", :bold),
+            ui.color("Name", :bold),
+            ui.color("VCPUs", :bold),
+            ui.color("RAM", :bold),
+            ui.color("Disk", :bold),
           ]
         end
         connection.flavors.sort_by(&:id).each do |flavor|
-          bits = flavor.respond_to?(:bits) ? "#{flavor.bits.to_s}-bit" : ""
+          bits = flavor.respond_to?(:bits) ? "#{flavor.bits}-bit" : ""
 
           flavor_list << flavor.id.to_s
           flavor_list << flavor.name
           flavor_list << bits if version_one?
           flavor_list << flavor.vcpus.to_s unless version_one?
-          flavor_list << "#{flavor.ram.to_s}"
-          flavor_list << "#{flavor.disk.to_s} GB"
+          flavor_list << "#{flavor.ram}"
+          flavor_list << "#{flavor.disk} GB"
         end
-          puts ui.list(flavor_list, :uneven_columns_across, 5)
+        puts ui.list(flavor_list, :uneven_columns_across, 5)
       end
     end
   end

data/lib/chef/knife/rackspace_image_list.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Seth Chisamore (<schisamo@opscode.com>)
-# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# Author:: Seth Chisamore (<schisamo@chef.io>)
+# Copyright:: Copyright (c) 2011-2016 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require 'chef/knife/rackspace_base'
+require "chef/knife/rackspace_base"
 
 class Chef
   class Knife
@@ -28,8 +28,8 @@ class Chef
 
       def run
         image_list = [
-          ui.color('ID', :bold),
-          ui.color('Name', :bold)
+          ui.color("ID", :bold),
+          ui.color("Name", :bold),
         ]
 
         connection.images.sort_by(&:name).each do |image|

data/lib/chef/knife/rackspace_network_create.rb

@@ -1,4 +1,4 @@
-require 'chef/knife/rackspace_base'
+require "chef/knife/rackspace_base"
 
 class Chef
   class Knife
@@ -26,9 +26,9 @@ class Chef
           exit 1
         else
           networks_list = [
-            ui.color('Label', :bold),
-            ui.color('CIDR', :bold),
-            ui.color('ID', :bold)
+            ui.color("Label", :bold),
+            ui.color("CIDR", :bold),
+            ui.color("ID", :bold),
           ]
         end
         options = {}

data/lib/chef/knife/rackspace_network_delete.rb

@@ -1,4 +1,4 @@
-require 'chef/knife/rackspace_base'
+require "chef/knife/rackspace_base"
 
 class Chef
   class Knife
@@ -15,7 +15,7 @@ class Chef
         else
           @name_args.each do |net_id|
             network = connection.networks.get(net_id)
-            unless(network)
+            unless network
               ui.error "Could not locate network: #{net_id}"
               exit 1
             end

data/lib/chef/knife/rackspace_network_list.rb

@@ -1,4 +1,4 @@
-require 'chef/knife/rackspace_base'
+require "chef/knife/rackspace_base"
 
 class Chef
   class Knife
@@ -14,9 +14,9 @@ class Chef
           exit 1
         else
           networks_list = [
-            ui.color('Label', :bold),
-            ui.color('CIDR', :bold),
-            ui.color('ID', :bold)
+            ui.color("Label", :bold),
+            ui.color("CIDR", :bold),
+            ui.color("ID", :bold),
           ]
         end
         connection.networks.sort_by(&:id).each do |network|

data/lib/chef/knife/rackspace_server_create.rb

@@ -1,7 +1,7 @@
 #
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Matt Ray (<matt@opscode.com>)
-# Copyright:: Copyright (c) 2009-2012 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Matt Ray (<matt@chef.io>)
+# Copyright:: Copyright (c) 2009-2016 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,9 +17,9 @@
 # limitations under the License.
 #
 
-require 'chef/knife/rackspace_base'
-require 'chef/knife/winrm_base'
-require 'chef/knife'
+require "chef/knife/rackspace_base"
+require "chef/knife/winrm_base"
+require "chef/knife"
 
 class Chef
   class Knife
@@ -28,12 +28,11 @@ class Chef
       include Knife::RackspaceBase
       include Chef::Knife::WinrmBase
 
-
       deps do
-        require 'fog'
-        require 'readline'
-        require 'chef/json_compat'
-        require 'chef/knife/bootstrap'
+        require "fog/rackspace"
+        require "readline"
+        require "chef/json_compat"
+        require "chef/knife/bootstrap"
         Chef::Knife::Bootstrap.load_deps
       end
 
@@ -54,6 +53,12 @@ class Chef
         :description => "The image of the server",
         :proc => Proc.new { |i| Chef::Config[:knife][:image] = i.to_s }
 
+      option :boot_volume_size,
+        :long => "--boot-volume-size GB",
+        :description => "The size of the CBS to use as the server's boot device",
+        :proc => Proc.new { |i| Chef::Config[:knife][:boot_volume_size] = i.to_s },
+        :default => 100
+
       option :boot_volume_id,
         :short => "-B BOOT_VOLUME_ID",
         :long => "--boot-volume-id UUID",
@@ -73,7 +78,7 @@ class Chef
       option :bootstrap_network,
         :long => "--bootstrap-network LABEL",
         :description => "Use IP address on this network for bootstrap",
-        :default => 'public'
+        :default => "public"
 
       option :private_network,
         :long => "--private-network",
@@ -106,7 +111,8 @@ class Chef
 
       option :prerelease,
         :long => "--prerelease",
-        :description => "Install the pre-release chef gems"
+        :description => "Install the pre-release chef gems",
+        :default => false
 
       option :bootstrap_version,
         :long => "--bootstrap-version VERSION",
@@ -143,8 +149,8 @@ class Chef
         :short => "-M JSON",
         :long => "--rackspace-metadata JSON",
         :description => "JSON string version of metadata hash to be supplied with the server create call",
-        :proc => Proc.new { |m| Chef::Config[:knife][:rackspace_metadata] = JSON.parse(m) },
-        :default => ""
+        :proc => lambda { |m| JSON.parse(m) },
+        :default => {}
 
       option :rackconnect_wait,
         :long => "--rackconnect-wait",
@@ -153,8 +159,8 @@ class Chef
         :default => false
 
       option :rackconnect_v3_network_id,
-        :long => '--rackconnect-v3-network-id ID',
-        :description => 'Rackconnect V3 ONLY: Link a new server to an existing network',
+        :long => "--rackconnect-v3-network-id ID",
+        :description => "Rackconnect V3 ONLY: Link a new server to an existing network",
         :proc => lambda { |o| Chef::Config[:knife][:rackconnect_v3_network_id] = o },
         :default => nil
 
@@ -207,7 +213,7 @@ class Chef
         :default => true
 
       option :network,
-        :long => '--network [LABEL_OR_ID]',
+        :long => "--network [LABEL_OR_ID]",
         :description => "Add private network. Use multiple --network options to specify multiple networks.",
         :proc => Proc.new{ |name|
           Chef::Config[:knife][:rackspace_networks] ||= []
@@ -223,7 +229,7 @@ class Chef
         :long => "--server-create-timeout timeout",
         :description => "How long to wait until the server is ready; default is 1200 seconds",
         :default => 1200,
-        :proc => Proc.new { |v| Chef::Config[:knife][:server_create_timeout] = v}
+        :proc => Proc.new { |v| Chef::Config[:knife][:server_create_timeout] = v }
 
       option :bootstrap_proxy,
         :long => "--bootstrap-proxy PROXY_URL",
@@ -232,9 +238,8 @@ class Chef
 
       option :rackspace_disk_config,
         :long => "--rackspace-disk-config DISKCONFIG",
-        :description => "Specify if want to manage your own disk partitioning scheme (AUTO or MANUAL), default is AUTO",
-        :proc => Proc.new { |k| Chef::Config[:knife][:rackspace_disk_config] = k },
-        :default => "AUTO"
+        :description => "Specify if want to manage your own disk partitioning scheme (AUTO or MANUAL)",
+        :proc => Proc.new { |k| Chef::Config[:knife][:rackspace_disk_config] = k }
 
       option :rackspace_config_drive,
         :long => "--rackspace_config_drive CONFIGDRIVE",
@@ -259,15 +264,15 @@ class Chef
         :proc => Proc.new { |sf| Chef::Config[:knife][:secret_file] = sf }
 
       option :bootstrap_vault_file,
-        :long        => '--bootstrap-vault-file VAULT_FILE',
-        :description => 'A JSON file with a list of vault(s) and item(s) to be updated'
+        :long        => "--bootstrap-vault-file VAULT_FILE",
+        :description => "A JSON file with a list of vault(s) and item(s) to be updated"
 
       option :bootstrap_vault_json,
-        :long        => '--bootstrap-vault-json VAULT_JSON',
-        :description => 'A JSON string with the vault(s) and item(s) to be updated'
+        :long        => "--bootstrap-vault-json VAULT_JSON",
+        :description => "A JSON string with the vault(s) and item(s) to be updated"
 
       option :bootstrap_vault_item,
-        :long        => '--bootstrap-vault-item VAULT_ITEM',
+        :long        => "--bootstrap-vault-item VAULT_ITEM",
         :description => 'A single vault and item to update as "vault:item"',
         :proc        => Proc.new { |i|
           (vault, item) = i.split(/:/)
@@ -278,21 +283,21 @@ class Chef
         }
 
       def load_winrm_deps
-        require 'winrm'
-        require 'em-winrm'
-        require 'chef/knife/bootstrap_windows_winrm'
-        require 'chef/knife/core/windows_bootstrap_context'
-        require 'chef/knife/winrm'
+        require "winrm"
+        require "em-winrm"
+        require "chef/knife/bootstrap_windows_winrm"
+        require "chef/knife/core/windows_bootstrap_context"
+        require "chef/knife/winrm"
       end
 
       def tcp_test_ssh(server, bootstrap_ip)
-        return true unless config[:tcp_test_ssh] != nil
+        return true unless locate_config_value(:tcp_test_ssh) != nil
 
-        limit = Chef::Config[:knife][:retry_ssh_limit].to_i
+        limit = locate_config_value(:retry_ssh_limit).to_i
         count = 0
 
         begin
-          Net::SSH.start(bootstrap_ip, 'root', :password => server.password ) do |ssh|
+          Net::SSH.start(bootstrap_ip, "root", :password => server.password ) do |ssh|
             Chef::Log.debug("sshd accepting connections on #{bootstrap_ip}")
             break
           end
@@ -300,8 +305,8 @@ class Chef
           count += 1
 
           if count <= limit
-            print '.'
-            sleep config[:retry_ssh_every].to_i
+            print "."
+            sleep locate_config_value(:retry_ssh_every).to_i
             tcp_test_ssh(server, bootstrap_ip)
           else
             ui.error "Unable to SSH into #{bootstrap_ip}"
@@ -311,7 +316,7 @@ class Chef
       end
 
       def parse_file_argument(arg)
-        dest, src = arg.split('=')
+        dest, src = arg.split("=")
         unless dest && src
           ui.error "Unable to process file arguments #{arg}. The --file option requires both the destination on the remote machine as well as the local source be supplied using the form DESTINATION-PATH=SOURCE-PATH"
           exit 1
@@ -331,7 +336,7 @@ class Chef
       end
 
       def files
-        return {} unless  Chef::Config[:knife][:file]
+        return {} unless Chef::Config[:knife][:file]
 
         files = []
         Chef::Config[:knife][:file].each do |arg|
@@ -339,14 +344,12 @@ class Chef
           Chef::Log.debug("Inject file #{src} into #{dest}")
           files << {
             :path => dest,
-            :contents => encode_file(src)
+            :contents => encode_file(src),
           }
         end
         files
       end
 
-
-
       def tcp_test_winrm(hostname, port)
         TCPSocket.new(hostname, port)
         return true
@@ -372,18 +375,18 @@ class Chef
         $stdout.sync = true
 
         server_create_options = {
-          :metadata => Chef::Config[:knife][:rackspace_metadata],
-          :disk_config => Chef::Config[:knife][:rackspace_disk_config],
+          :metadata => locate_config_value(:rackspace_metadata),
+          :disk_config => locate_config_value(:rackspace_disk_config),
           :user_data => user_data,
           :config_drive => locate_config_value(:rackspace_config_drive) || false,
           :personality => files,
-          :key_name => Chef::Config[:knife][:rackspace_ssh_keypair],
+          :key_name => locate_config_value(:rackspace_ssh_keypair),
           :name => get_node_name(config[:chef_node_name] || config[:server_name]),
-          :networks => get_networks(Chef::Config[:knife][:rackspace_networks], Chef::Config[:knife][:rackconnect_v3_network_id]),
+          :networks => get_networks(locate_config_value(:rackspace_networks), locate_config_value(:rackconnect_v3_network_id)),
         }
 
         # Maybe deprecate this option at some point
-        config[:bootstrap_network] = 'private' if config[:private_network]
+        config[:bootstrap_network] = "private" if locate_config_value(:private_network)
 
         flavor_id = locate_config_value(:flavor)
         flavor = connection.flavors.get(flavor_id)
@@ -400,24 +403,25 @@ class Chef
         # In the case we are trying to create one of these flavors, we should
         # swap out the image_id argument with the boot_image_id argument.
         if flavor.disk == 0
-          server_create_options[:image_id] = ''
-          server_create_options[:boot_volume_id] = Chef::Config[:knife][:boot_volume_id]
-          server_create_options[:boot_image_id] = Chef::Config[:knife][:image]
+          server_create_options[:image_id] = ""
+          server_create_options[:boot_volume_id] = locate_config_value(:boot_volume_id)
+          server_create_options[:boot_image_id] = locate_config_value(:image)
+          server_create_options[:boot_volume_size] = locate_config_value(:boot_volume_size)
 
           if server_create_options[:boot_image_id] && server_create_options[:boot_volume_id]
-            ui.error('Please specify exactly one of --boot-volume-id (-B) and --image (-I)')
+            ui.error("Please specify either --boot-volume-id (-B) or --image (-I)")
             exit 1
           end
         else
-          server_create_options[:image_id] = Chef::Config[:knife][:image]
+          server_create_options[:image_id] = locate_config_value(:image)
 
           if !server_create_options[:image_id]
-            ui.error('Please specify an Image ID for the server with --image (-I)')
+            ui.error("Please specify an Image ID for the server with --image (-I)")
             exit 1
           end
         end
 
-        if locate_config_value(:bootstrap_protocol) == 'winrm'
+        if locate_config_value(:bootstrap_protocol) == "winrm"
           load_winrm_deps
         end
 
@@ -429,8 +433,8 @@ class Chef
           server.save(:networks => server_create_options[:networks])
         end
 
-        rackconnect_wait = Chef::Config[:knife][:rackconnect_wait] || config[:rackconnect_wait]
-        rackspace_servicelevel_wait = Chef::Config[:knife][:rackspace_servicelevel_wait] || config[:rackspace_servicelevel_wait]
+        rackconnect_wait = locate_config_value(:rackconnect_wait)
+        rackspace_servicelevel_wait = locate_config_value(:rackspace_servicelevel_wait)
 
         msg_pair("Instance ID", server.id)
         msg_pair("Host ID", server.host_id)
@@ -440,37 +444,37 @@ class Chef
         msg_pair("Boot Image ID", server.boot_image_id) if server.boot_image_id
         msg_pair("Metadata", server.metadata.all)
         msg_pair("ConfigDrive", server.config_drive)
-        msg_pair("UserData", Chef::Config[:knife][:rackspace_user_data])
-        msg_pair("RackConnect Wait", rackconnect_wait ? 'yes' : 'no')
-        msg_pair("RackConnect V3", Chef::Config[:knife][:rackconnect_v3_network_id] ? 'yes' : 'no')
-        msg_pair("ServiceLevel Wait", rackspace_servicelevel_wait ? 'yes' : 'no')
-        msg_pair("SSH Key", Chef::Config[:knife][:rackspace_ssh_keypair])
+        msg_pair("UserData", locate_config_value(:rackspace_user_data))
+        msg_pair("RackConnect Wait", rackconnect_wait ? "yes" : "no")
+        msg_pair("RackConnect V3", locate_config_value(:rackconnect_v3_network_id) ? "yes" : "no")
+        msg_pair("ServiceLevel Wait", rackspace_servicelevel_wait ? "yes" : "no")
+        msg_pair("SSH Key", locate_config_value(:rackspace_ssh_keypair))
 
         # wait for it to be ready to do stuff
         begin
-          server.wait_for(Integer(locate_config_value(:server_create_timeout))) {
+          server.wait_for(Integer(locate_config_value(:server_create_timeout))) do
             print ".";
             Chef::Log.debug("#{progress}%")
 
-            if rackconnect_wait and rackspace_servicelevel_wait
+            if rackconnect_wait && rackspace_servicelevel_wait
               Chef::Log.debug("rackconnect_automation_status: #{metadata.all['rackconnect_automation_status']}")
               Chef::Log.debug("rax_service_level_automation: #{metadata.all['rax_service_level_automation']}")
-              ready? and metadata.all['rackconnect_automation_status'] == 'DEPLOYED' and metadata.all['rax_service_level_automation'] == 'Complete'
+              ready? && metadata.all["rackconnect_automation_status"] == "DEPLOYED" && metadata.all["rax_service_level_automation"] == "Complete"
             elsif rackconnect_wait
               Chef::Log.debug("rackconnect_automation_status: #{metadata.all['rackconnect_automation_status']}")
-              ready? and metadata.all['rackconnect_automation_status'] == 'DEPLOYED'
+              ready? && metadata.all["rackconnect_automation_status"] == "DEPLOYED"
             elsif rackspace_servicelevel_wait
               Chef::Log.debug("rax_service_level_automation: #{metadata.all['rax_service_level_automation']}")
-              ready? and metadata.all['rax_service_level_automation'] == 'Complete'
+              ready? && metadata.all["rax_service_level_automation"] == "Complete"
             else
               ready?
             end
-          }
+          end
         rescue Fog::Errors::TimeoutError
-          ui.error('Timeout waiting for the server to be created')
-          msg_pair('Progress', "#{server.progress}%")
-          msg_pair('rackconnect_automation_status', server.metadata.all['rackconnect_automation_status'])
-          msg_pair('rax_service_level_automation', server.metadata.all['rax_service_level_automation'])
+          ui.error("Timeout waiting for the server to be created")
+          msg_pair("Progress", "#{server.progress}%")
+          msg_pair("rackconnect_automation_status", server.metadata.all["rackconnect_automation_status"])
+          msg_pair("rax_service_level_automation", server.metadata.all["rax_service_level_automation"])
           Chef::Application.fatal! 'Server didn\'t finish on time'
         end
 
@@ -480,7 +484,7 @@ class Chef
 
         puts("\n")
 
-        if Chef::Config[:knife][:rackconnect_v3_network_id]
+        if locate_config_value(:rackconnect_v3_network_id)
           print "\n#{ui.color("Setting up RackconnectV3 network and IPs", :magenta)}"
           setup_rackconnect_network!(server)
           while server.ipv4_address == ""
@@ -489,17 +493,17 @@ class Chef
           end
         end
 
-        if server_create_options[:networks] && Chef::Config[:knife][:rackspace_networks]
-          msg_pair("Networks", Chef::Config[:knife][:rackspace_networks].sort.join(', '))
+        if server_create_options[:networks] && locate_config_value(:rackspace_networks)
+          msg_pair("Networks", locate_config_value(:rackspace_networks).sort.join(", "))
         end
 
         msg_pair("Public DNS Name", public_dns_name(server))
-        msg_pair("Public IP Address", ip_address(server, 'public'))
-        msg_pair("Private IP Address", ip_address(server, 'private'))
+        msg_pair("Public IP Address", ip_address(server, "public"))
+        msg_pair("Private IP Address", ip_address(server, "private"))
         msg_pair("Password", server.password)
         msg_pair("Metadata", server.metadata.all)
 
-        bootstrap_ip_address = ip_address(server, config[:bootstrap_network])
+        bootstrap_ip_address = ip_address(server, locate_config_value(:bootstrap_network))
 
         Chef::Log.debug("Bootstrap IP Address #{bootstrap_ip_address}")
         if bootstrap_ip_address.nil?
@@ -507,7 +511,7 @@ class Chef
           exit 1
         end
 
-        if locate_config_value(:bootstrap_protocol) == 'winrm'
+        if locate_config_value(:bootstrap_protocol) == "winrm"
           print "\n#{ui.color("Waiting for winrm", :magenta)}"
           print(".") until tcp_test_winrm(bootstrap_ip_address, locate_config_value(:winrm_port))
           bootstrap_for_windows_node(server, bootstrap_ip_address).run
@@ -526,11 +530,11 @@ class Chef
         msg_pair("Boot Image ID", server.boot_image_id) if server.boot_image_id
         msg_pair("Metadata", server.metadata)
         msg_pair("Public DNS Name", public_dns_name(server))
-        msg_pair("Public IP Address", ip_address(server, 'public'))
-        msg_pair("Private IP Address", ip_address(server, 'private'))
+        msg_pair("Public IP Address", ip_address(server, "public"))
+        msg_pair("Private IP Address", ip_address(server, "private"))
         msg_pair("Password", server.password)
-        msg_pair("Environment", config[:environment] || '_default')
-        msg_pair("Run List", config[:run_list].join(', '))
+        msg_pair("Environment", config[:environment] || "_default")
+        msg_pair("Run List", config[:run_list].join(", "))
       end
 
       def setup_rackconnect_network!(server)
@@ -542,8 +546,8 @@ class Chef
         Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
           begin
             req                 = Net::HTTP::Post.new(uri.request_uri)
-            req['X-Auth-Token'] = auth_token
-            req['Content-Type'] = 'application/json'
+            req["X-Auth-Token"] = auth_token
+            req["Content-Type"] = "application/json"
             req.body            = JSON.dump("cloud_server" => { "id" => server.id })
             http.use_ssl        = true
             http.request req
@@ -554,7 +558,7 @@ class Chef
       end
 
       def user_data
-        file = Chef::Config[:knife][:rackspace_user_data]
+        file = locate_config_value(:rackspace_user_data)
         return unless file
 
         begin
@@ -570,17 +574,17 @@ class Chef
       def bootstrap_for_node(server, bootstrap_ip_address)
         bootstrap = Chef::Knife::Bootstrap.new
         bootstrap.name_args = [bootstrap_ip_address]
-        bootstrap.config[:ssh_user] = config[:ssh_user] || "root"
+        bootstrap.config[:ssh_user] = locate_config_value(:ssh_user) || "root"
         bootstrap.config[:ssh_password] = server.password
-        bootstrap.config[:ssh_port] = config[:ssh_port] || Chef::Config[:knife][:ssh_port]
-        bootstrap.config[:identity_file] = config[:identity_file]
-        bootstrap.config[:host_key_verify] = config[:host_key_verify]
-        bootstrap.config[:bootstrap_vault_file] = config[:bootstrap_vault_file] if config[:bootstrap_vault_file]
-        bootstrap.config[:bootstrap_vault_json] = config[:bootstrap_vault_json] if config[:bootstrap_vault_json]
-        bootstrap.config[:bootstrap_vault_item] = config[:bootstrap_vault_item] if config[:bootstrap_vault_item]
+        bootstrap.config[:ssh_port] = locate_config_value(:ssh_port)
+        bootstrap.config[:identity_file] = locate_config_value(:identity_file)
+        bootstrap.config[:host_key_verify] = locate_config_value(:host_key_verify)
+        bootstrap.config[:bootstrap_vault_file] = locate_config_value(:bootstrap_vault_file) if locate_config_value(:bootstrap_vault_file)
+        bootstrap.config[:bootstrap_vault_json] = locate_config_value(:bootstrap_vault_json) if locate_config_value(:bootstrap_vault_json)
+        bootstrap.config[:bootstrap_vault_item] = locate_config_value(:bootstrap_vault_item) if locate_config_value(:bootstrap_vault_item)
         # bootstrap will run as root...sudo (by default) also messes up Ohai on CentOS boxes
-        bootstrap.config[:use_sudo] = true unless config[:ssh_user] == 'root'
-        bootstrap.config[:distro] = locate_config_value(:distro)  || 'chef-full'
+        bootstrap.config[:use_sudo] = true unless locate_config_value(:ssh_user) == "root"
+        bootstrap.config[:distro] = locate_config_value(:distro) || "chef-full"
         bootstrap_common_params(bootstrap, server)
       end
 
@@ -592,15 +596,16 @@ class Chef
         else
           bootstrap.config[:chef_node_name] = config[:chef_node_name] || server.name
         end
-        bootstrap.config[:prerelease] = config[:prerelease]
+        bootstrap.config[:prerelease] = locate_config_value(:prerelease)
         bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
         bootstrap.config[:template_file] = locate_config_value(:template_file)
-        bootstrap.config[:first_boot_attributes] = config[:first_boot_attributes]
+        bootstrap.config[:first_boot_attributes] = locate_config_value(:first_boot_attributes)
         bootstrap.config[:bootstrap_proxy] = locate_config_value(:bootstrap_proxy)
-        bootstrap.config[:encrypted_data_bag_secret] = config[:encrypted_data_bag_secret]
-        bootstrap.config[:encrypted_data_bag_secret_file] = config[:encrypted_data_bag_secret_file]
+#        TODO: Remove dead code. There's no command line parameter for these two.
+#        bootstrap.config[:encrypted_data_bag_secret] = config[:encrypted_data_bag_secret]
+#        bootstrap.config[:encrypted_data_bag_secret_file] = config[:encrypted_data_bag_secret_file]
         bootstrap.config[:secret] = locate_config_value(:secret)
-        bootstrap.config[:secret_file] = locate_config_value(:secret_file)  || ""
+        bootstrap.config[:secret_file] = locate_config_value(:secret_file) || ""
 
         Chef::Config[:knife][:hints] ||= {}
         Chef::Config[:knife][:hints]["rackspace"] ||= {}
@@ -610,11 +615,11 @@ class Chef
       def bootstrap_for_windows_node(server, bootstrap_ip_address)
         bootstrap = Chef::Knife::BootstrapWindowsWinrm.new
         bootstrap.name_args = [bootstrap_ip_address]
-        bootstrap.config[:winrm_user] = locate_config_value(:winrm_user) || 'Administrator'
+        bootstrap.config[:winrm_user] = locate_config_value(:winrm_user) || "Administrator"
         bootstrap.config[:winrm_password] = locate_config_value(:winrm_password) || server.password
         bootstrap.config[:winrm_transport] = locate_config_value(:winrm_transport)
         bootstrap.config[:winrm_port] = locate_config_value(:winrm_port)
-        bootstrap.config[:distro] = locate_config_value(:distro)  || 'windows-chef-client-msi'
+        bootstrap.config[:distro] = locate_config_value(:distro) || "windows-chef-client-msi"
         bootstrap_common_params(bootstrap, server)
       end
 
@@ -623,29 +628,29 @@ class Chef
     def get_node_name(chef_node_name)
       return chef_node_name unless chef_node_name.nil?
       #lazy uuids
-      chef_node_name = "rs-"+rand.to_s.split('.')[1] unless version_one?
+      chef_node_name = "rs-" + rand.to_s.split(".")[1] unless version_one?
     end
 
-    def get_networks(names, rackconnect3=false)
+    def get_networks(names, rackconnect3 = false)
       names = Array(names)
 
-      if(Chef::Config[:knife][:rackspace_version] == 'v2')
-        if rackconnect3
-          nets = [Chef::Config[:knife][:rackconnect_v3_network_id]]
-        elsif config[:default_networks]
-          nets = [
-            '00000000-0000-0000-0000-000000000000',
-            '11111111-1111-1111-1111-111111111111'
-          ]
-        else
-          nets  = []
-        end
+      if locate_config_value(:rackspace_version) == "v2"
+        nets = if rackconnect3
+                 [locate_config_value(:rackconnect_v3_network_id)]
+               elsif locate_config_value(:default_networks)
+                 [
+                   "00000000-0000-0000-0000-000000000000",
+                   "11111111-1111-1111-1111-111111111111",
+                 ]
+               else
+                 []
+               end
 
         available_networks = connection.networks.all
 
         names.each do |name|
-          net = available_networks.detect{|n| n.label == name || n.id == name}
-          if(net)
+          net = available_networks.detect { |n| n.label == name || n.id == name }
+          if net
             nets << net.id
           else
             ui.error("Failed to locate network: #{name}")
@@ -653,7 +658,7 @@ class Chef
           end
         end
         nets
-      elsif(names && !names.empty?)
+      elsif names && !names.empty?
         ui.error("Custom networks are only available in v2 API")
         exit 1
       end