knife-rackspace 1.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3424287dbc7b2fc0cacf8f5d59f5f270620f114f
-  data.tar.gz: 622cf2499996948177d909c495ca9d036a9cf149
+SHA256:
+  metadata.gz: 4d076b1123a47563c50cc2113b132fcad24792de369fefda5d879af3def6b6fb
+  data.tar.gz: 55fb1c587e13f2a029783891c9cce1585e120fb6f3eb9df2fe5779775fd44982
 SHA512:
-  metadata.gz: a55cb84a25d9374ec39003f52312c58960e907eeff6f68612fd63e77d103ac773261c23a384fc12389b1ddcc079d893440228c6f69eac81a529509a550bc57fc
-  data.tar.gz: c727dbaa60bc04a9f2c5899c193cad18555e2ec9bcbd5493096b83a72a5dab724130bd913775e91b8dc59fd2ddae2b7146a0552f0395677b4fb670ab75027037
+  metadata.gz: 445fe503b0d35b9c07151dc45ab08167ed565ff68ad060e83582976ca5b86bbf517640b76e504fc2209fa8e00a009de863382040fe7cf4eaeb985a973214a48f
+  data.tar.gz: c9936580b82f1d82cc204697c0644c38cf772ea135aee27b24af1ec00bd9b69e1545d5361ffde45095d569e35640b4fc6ccfad74ebf5e1be6dfa9e07aa6020b6

data/lib/chef/knife/rackspace_base.rb

@@ -37,37 +37,37 @@ class Chef
           end
 
           option :rackspace_api_key,
-            :short => "-K KEY",
-            :long => "--rackspace-api-key KEY",
-            :description => "Your rackspace API key",
-            :proc => Proc.new { |key| Chef::Config[:knife][:rackspace_api_key] = key }
+            short: "-K KEY",
+            long: "--rackspace-api-key KEY",
+            description: "Your rackspace API key",
+            proc: Proc.new { |key| Chef::Config[:knife][:rackspace_api_key] = key }
 
           option :rackspace_username,
-            :short => "-A USERNAME",
-            :long => "--rackspace-username USERNAME",
-            :description => "Your rackspace API username",
-            :proc => Proc.new { |username| Chef::Config[:knife][:rackspace_username] = username }
+            short: "-A USERNAME",
+            long: "--rackspace-username USERNAME",
+            description: "Your rackspace API username",
+            proc: Proc.new { |username| Chef::Config[:knife][:rackspace_username] = username }
 
           option :rackspace_version,
-            :long => "--rackspace-version VERSION",
-            :description => "Rackspace Cloud Servers API version",
-            :default => "v2",
-            :proc => Proc.new { |version| Chef::Config[:knife][:rackspace_version] = version }
+            long: "--rackspace-version VERSION",
+            description: "Rackspace Cloud Servers API version",
+            default: "v2",
+            proc: Proc.new { |version| Chef::Config[:knife][:rackspace_version] = version }
 
           option :rackspace_auth_url,
-            :long => "--rackspace-auth-url URL",
-            :description => "Your rackspace API auth url",
-            :proc => Proc.new { |url| Chef::Config[:knife][:rackspace_auth_url] = url }
+            long: "--rackspace-auth-url URL",
+            description: "Your rackspace API auth url",
+            proc: Proc.new { |url| Chef::Config[:knife][:rackspace_auth_url] = url }
 
           option :rackspace_region,
-            :long => "--rackspace-region REGION",
-            :description => "Your rackspace region",
-            :proc => Proc.new { |region| Chef::Config[:knife][:rackspace_region] = region }
+            long: "--rackspace-region REGION",
+            description: "Your rackspace region",
+            proc: Proc.new { |region| Chef::Config[:knife][:rackspace_region] = region }
 
           option :file,
-            :long => "--file DESTINATION-PATH=SOURCE-PATH",
-            :description => "File to inject on node",
-            :proc => Proc.new {|arg|
+            long: "--file DESTINATION-PATH=SOURCE-PATH",
+            description: "File to inject on node",
+            proc: Proc.new { |arg|
               Chef::Config[:knife][:file] ||= []
               Chef::Config[:knife][:file] << arg
             }
@@ -94,14 +94,14 @@ class Chef
           region_warning_for_v1
           @connection ||= begin
             connection = Fog::Compute.new(connection_params({
-              :version => "v1",
+              version: "v1",
               }))
           end
         else
           Chef::Log.debug("rackspace v2")
           @connection ||= begin
             connection = Fog::Compute.new(connection_params({
-              :version => "v2",
+              version: "v2",
             }))
           end
         end
@@ -131,22 +131,22 @@ class Chef
         end
 
         hash = options.merge({
-          :provider => "Rackspace",
-          :rackspace_api_key => locate_config_value(:rackspace_api_key),
-          :rackspace_username => username,
-          :rackspace_auth_url => auth_endpoint,
-          :rackspace_region => locate_config_value(:rackspace_region),
+          provider: "Rackspace",
+          rackspace_api_key: locate_config_value(:rackspace_api_key),
+          rackspace_username: username,
+          rackspace_auth_url: auth_endpoint,
+          rackspace_region: locate_config_value(:rackspace_region),
         })
 
         hash[:connection_options] ||= {}
-        Chef::Log.debug("https_proxy #{ Chef::Config[:https_proxy] || "<not specified>"} (config)")
-        Chef::Log.debug("http_proxy #{ Chef::Config[:http_proxy] || "<not specified>"} (config)")
-        if Chef::Config.has_key?(:https_proxy) || Chef::Config.has_key?(:http_proxy)
-          hash[:connection_options] = { :proxy => Chef::Config[:https_proxy] || Chef::Config[:http_proxy] }
+        Chef::Log.debug("https_proxy #{Chef::Config[:https_proxy] || "<not specified>"} (config)")
+        Chef::Log.debug("http_proxy #{Chef::Config[:http_proxy] || "<not specified>"} (config)")
+        if Chef::Config.key?(:https_proxy) || Chef::Config.key?(:http_proxy)
+          hash[:connection_options] = { proxy: Chef::Config[:https_proxy] || Chef::Config[:http_proxy] }
         end
         Chef::Log.debug("using proxy #{hash[:connection_options][:proxy] || "<none>"} (config)")
-        Chef::Log.debug("ssl_verify_peer #{Chef::Config[:knife].has_key?(:ssl_verify_peer) ? Chef::Config[:knife][:ssl_verify_peer] : "<not specified>"} (config)")
-        hash[:connection_options][:ssl_verify_peer] = Chef::Config[:knife][:ssl_verify_peer] if Chef::Config[:knife].has_key?(:ssl_verify_peer)
+        Chef::Log.debug("ssl_verify_peer #{Chef::Config[:knife].key?(:ssl_verify_peer) ? Chef::Config[:knife][:ssl_verify_peer] : "<not specified>"} (config)")
+        hash[:connection_options][:ssl_verify_peer] = Chef::Config[:knife][:ssl_verify_peer] if Chef::Config[:knife].key?(:ssl_verify_peer)
 
         hash
       end
@@ -154,6 +154,7 @@ class Chef
       def auth_endpoint
         url = locate_config_value(:rackspace_auth_url)
         return url if url
+
         (locate_config_value(:rackspace_region) == "lon") ? ::Fog::Rackspace::UK_AUTH_ENDPOINT : ::Fog::Rackspace::US_AUTH_ENDPOINT
       end
 
@@ -188,8 +189,8 @@ class Chef
         if public_ip_address = ip_address(server, "public")
           @public_dns_name ||= begin
             Resolv.getname(public_ip_address)
-          rescue
-            "#{public_ip_address}.xip.io"
+                               rescue
+                                 "#{public_ip_address}.xip.io"
           end
         end
       end
@@ -206,11 +207,11 @@ class Chef
       end
 
       def v1_public_ip(server)
-        server.public_ip_address == nil ? "" : server.public_ip_address
+        server.public_ip_address.nil? ? "" : server.public_ip_address
       end
 
       def v1_private_ip(server)
-        server.addresses["private"].first == nil ? "" : server.addresses["private"].first
+        server.addresses["private"].first.nil? ? "" : server.addresses["private"].first
       end
 
       def v2_ip_address(server, network)
@@ -219,7 +220,7 @@ class Chef
       end
 
       def v2_access_ip(server)
-        server.access_ipv4_address == nil ? "" : server.access_ipv4_address
+        server.access_ipv4_address.nil? ? "" : server.access_ipv4_address
       end
 
       def extract_ipv4_address(ip_addresses)

data/lib/chef/knife/rackspace_flavor_list.rb

@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require "chef/knife/rackspace_base"
+require_relative "rackspace_base"
 
 class Chef
   class Knife

data/lib/chef/knife/rackspace_image_list.rb

@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require "chef/knife/rackspace_base"
+require_relative "rackspace_base"
 
 class Chef
   class Knife

data/lib/chef/knife/rackspace_network_create.rb

@@ -1,4 +1,4 @@
-require "chef/knife/rackspace_base"
+require_relative "rackspace_base"
 
 class Chef
   class Knife
@@ -9,16 +9,16 @@ class Chef
       banner "knife rackspace network create (options)"
 
       option :label,
-        :short => "-L LABEL",
-        :long => "--label LABEL",
-        :description => "Label for the network",
-        :required => true
+        short: "-L LABEL",
+        long: "--label LABEL",
+        description: "Label for the network",
+        required: true
 
       option :cidr,
-        :short => "-C CIDR",
-        :long => "--cidr CIDR",
-        :description => "CIDR for the network",
-        :required => true
+        short: "-C CIDR",
+        long: "--cidr CIDR",
+        description: "CIDR for the network",
+        required: true
 
       def run
         if version_one?
@@ -32,7 +32,7 @@ class Chef
           ]
         end
         options = {}
-        [:cidr, :label].each do |key|
+        %i{cidr label}.each do |key|
           options[key] = config[key]
         end
         net = connection.networks.create(options)

data/lib/chef/knife/rackspace_network_delete.rb

@@ -1,4 +1,4 @@
-require "chef/knife/rackspace_base"
+require_relative "rackspace_base"
 
 class Chef
   class Knife

data/lib/chef/knife/rackspace_network_list.rb

@@ -1,4 +1,4 @@
-require "chef/knife/rackspace_base"
+require_relative "rackspace_base"
 
 class Chef
   class Knife

data/lib/chef/knife/rackspace_server_create.rb

@@ -17,7 +17,7 @@
 # limitations under the License.
 #
 
-require "chef/knife/rackspace_base"
+require_relative "rackspace_base"
 require "chef/knife/winrm_base"
 require "chef/knife"
 
@@ -41,240 +41,256 @@ class Chef
       attr_accessor :initial_sleep_delay
 
       option :flavor,
-        :short => "-f FLAVOR",
-        :long => "--flavor FLAVOR",
-        :description => "The flavor of server; default is 2 (512 MB)",
-        :proc => Proc.new { |f| Chef::Config[:knife][:flavor] = f.to_s },
-        :default => 2
+        short: "-f FLAVOR",
+        long: "--flavor FLAVOR",
+        description: "The flavor of server; default is 2 (512 MB)",
+        proc: Proc.new { |f| Chef::Config[:knife][:flavor] = f.to_s },
+        default: "2"
 
       option :image,
-        :short => "-I IMAGE",
-        :long => "--image IMAGE",
-        :description => "The image of the server",
-        :proc => Proc.new { |i| Chef::Config[:knife][:image] = i.to_s }
+        short: "-I IMAGE",
+        long: "--image IMAGE",
+        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
+        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",
-        :description => "The image CBS UUID to use as the server's boot device",
-        :proc => Proc.new { |i| Chef::Config[:knife][:boot_volume_id] = i.to_s }
+        short: "-B BOOT_VOLUME_ID",
+        long: "--boot-volume-id UUID",
+        description: "The image CBS UUID to use as the server's boot device",
+        proc: Proc.new { |i| Chef::Config[:knife][:boot_volume_id] = i.to_s }
 
       option :server_name,
-        :short => "-S NAME",
-        :long => "--server-name NAME",
-        :description => "The server name"
+        short: "-S NAME",
+        long: "--server-name NAME",
+        description: "The server name"
 
       option :chef_node_name,
-        :short => "-N NAME",
-        :long => "--node-name NAME",
-        :description => "The Chef node name for your new node"
+        short: "-N NAME",
+        long: "--node-name NAME",
+        description: "The Chef node name for your new node"
 
       option :bootstrap_network,
-        :long => "--bootstrap-network LABEL",
-        :description => "Use IP address on this network for bootstrap",
-        :default => "public"
+        long: "--bootstrap-network LABEL",
+        description: "Use IP address on this network for bootstrap",
+        default: "public"
 
       option :private_network,
-        :long => "--private-network",
-        :description => "Equivalent to --bootstrap-network private",
-        :boolean => true,
-        :default => false
+        long: "--private-network",
+        description: "Equivalent to --bootstrap-network private",
+        boolean: true,
+        default: false
 
       option :ssh_user,
-        :short => "-x USERNAME",
-        :long => "--ssh-user USERNAME",
-        :description => "The ssh username; default is 'root'",
-        :default => "root"
+        short: "-x USERNAME",
+        long: "--ssh-user USERNAME",
+        description: "The ssh username; default is 'root'",
+        default: "root"
 
       option :ssh_password,
-        :short => "-P PASSWORD",
-        :long => "--ssh-password PASSWORD",
-        :description => "The ssh password"
+        short: "-P PASSWORD",
+        long: "--ssh-password PASSWORD",
+        description: "The ssh password"
 
       option :ssh_port,
-        :short => "-p PORT",
-        :long => "--ssh-port PORT",
-        :description => "The ssh port",
-        :default => "22",
-        :proc => Proc.new { |key| Chef::Config[:knife][:ssh_port] = key }
+        short: "-p PORT",
+        long: "--ssh-port PORT",
+        description: "The ssh port",
+        default: "22",
+        proc: Proc.new { |key| Chef::Config[:knife][:ssh_port] = key }
 
       option :identity_file,
-        :short => "-i IDENTITY_FILE",
-        :long => "--identity-file IDENTITY_FILE",
-        :description => "The SSH identity file used for authentication"
+        short: "-i IDENTITY_FILE",
+        long: "--identity-file IDENTITY_FILE",
+        description: "The SSH identity file used for authentication"
 
       option :prerelease,
-        :long => "--prerelease",
-        :description => "Install the pre-release chef gems",
-        :default => false
+        long: "--prerelease",
+        description: "Install the pre-release chef gems",
+        default: false
 
       option :bootstrap_version,
-        :long => "--bootstrap-version VERSION",
-        :description => "The version of Chef to install",
-        :proc => Proc.new { |v| Chef::Config[:knife][:bootstrap_version] = v }
+        long: "--bootstrap-version VERSION",
+        description: "The version of Chef to install",
+        proc: Proc.new { |v| Chef::Config[:knife][:bootstrap_version] = v }
 
       option :distro,
-        :short => "-d DISTRO",
-        :long => "--distro DISTRO",
-        :description => "Bootstrap a distro using a template; default is 'chef-full'",
-        :proc => Proc.new { |d| Chef::Config[:knife][:distro] = d }
+        short: "-d DISTRO",
+        long: "--distro DISTRO",
+        description: "Bootstrap a distro using a template. [DEPRECATED] Use -t / --bootstrap-template option instead.",
+        proc: Proc.new { |v|
+          Chef::Log.fatal("[DEPRECATED] -d / --distro option is deprecated. Use --bootstrap-template option instead.")
+          v
+        }
 
+      # @todo When we no longer support Chef 13 this can just go away
       option :template_file,
-        :long => "--template-file TEMPLATE",
-        :description => "Full path to location of template to use",
-        :proc => Proc.new { |t| Chef::Config[:knife][:template_file] = t },
-        :default => false
+        long: "--template-file TEMPLATE",
+        description: "Full path to location of template to use. [DEPRECATED] Use -t / --bootstrap-template option instead.",
+        proc: Proc.new { |v|
+          Chef::Log.fatal("[DEPRECATED] --template-file option is deprecated. Use --bootstrap-template option instead.")
+          v
+        }
+
+      option :bootstrap_template,
+        short: "-t TEMPLATE",
+        long: "--bootstrap-template TEMPLATE",
+        description: "Bootstrap Chef using a built-in or custom template. Set to the full path of an erb template or use one of the built-in templates."
 
       option :run_list,
-        :short => "-r RUN_LIST",
-        :long => "--run-list RUN_LIST",
-        :description => "Comma separated list of roles/recipes to apply",
-        :proc => lambda { |o| o.split(/[\s,]+/) },
-        :default => []
+        short: "-r RUN_LIST",
+        long: "--run-list RUN_LIST",
+        description: "Comma separated list of roles/recipes to apply",
+        proc: lambda { |o| o.split(/[\s,]+/) },
+        default: []
 
       option :first_boot_attributes,
-        :short => "-j JSON_ATTRIBS",
-        :long => "--json-attributes",
-        :description => "A JSON string to be added to the first run of chef-client",
-        :proc => lambda { |o| JSON.parse(o) },
-        :default => {}
+        short: "-j JSON_ATTRIBS",
+        long: "--json-attributes",
+        description: "A JSON string to be added to the first run of chef-client",
+        proc: lambda { |o| JSON.parse(o) },
+        default: {}
 
       option :rackspace_metadata,
-        :short => "-M JSON",
-        :long => "--rackspace-metadata JSON",
-        :description => "JSON string version of metadata hash to be supplied with the server create call",
-        :proc => lambda { |m| JSON.parse(m) },
-        :default => {}
+        short: "-M JSON",
+        long: "--rackspace-metadata JSON",
+        description: "JSON string version of metadata hash to be supplied with the server create call",
+        proc: lambda { |m| JSON.parse(m) },
+        default: {}
 
       option :rackconnect_wait,
-        :long => "--rackconnect-wait",
-        :description => "Wait until the Rackconnect automation setup is complete before bootstrapping chef",
-        :boolean => true,
-        :default => false
+        long: "--rackconnect-wait",
+        description: "Wait until the Rackconnect automation setup is complete before bootstrapping chef",
+        boolean: true,
+        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",
-        :proc => lambda { |o| Chef::Config[:knife][:rackconnect_v3_network_id] = o },
-        :default => nil
+        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
 
       option :rackspace_servicelevel_wait,
-        :long => "--rackspace-servicelevel-wait",
-        :description => "Wait until the Rackspace service level automation setup is complete before bootstrapping chef",
-        :boolean => true,
-        :default => false
+        long: "--rackspace-servicelevel-wait",
+        description: "Wait until the Rackspace service level automation setup is complete before bootstrapping chef",
+        boolean: true,
+        default: false
 
       option :hint,
-        :long => "--hint HINT_NAME[=HINT_FILE]",
-        :description => "Specify Ohai Hint to be set on the bootstrap target.  Use multiple --hint options to specify multiple hints.",
-        :proc => Proc.new { |h|
+        long: "--hint HINT_NAME[=HINT_FILE]",
+        description: "Specify Ohai Hint to be set on the bootstrap target.  Use multiple --hint options to specify multiple hints.",
+        proc: Proc.new { |h|
           Chef::Config[:knife][:hints] ||= {}
           name, path = h.split("=")
-          Chef::Config[:knife][:hints][name] = path ? JSON.parse(::File.read(path)) : Hash.new
+          Chef::Config[:knife][:hints][name] = path ? JSON.parse(::File.read(path)) : {}
         }
 
       option :host_key_verify,
-        :long => "--[no-]host-key-verify",
-        :description => "Verify host key, enabled by default",
-        :boolean => true,
-        :default => true
+        long: "--[no-]host-key-verify",
+        description: "Verify host key, enabled by default",
+        boolean: true,
+        default: true
 
       option :tcp_test_ssh,
-        :long => "--[no-]tcp-test-ssh",
-        :description => "Check that SSH is available using a TCP check directly on port 22, enabled by default",
-        :boolean => true,
-        :default => true
+        long: "--[no-]tcp-test-ssh",
+        description: "Check that SSH is available using a TCP check directly on port 22, enabled by default",
+        boolean: true,
+        default: true
 
       option :ssh_wait_timeout,
-        :long => "--ssh-wait-timeout TIMEOUT",
-        :description => "The ssh wait timeout, before attempting ssh",
-        :default => "0"
+        long: "--ssh-wait-timeout TIMEOUT",
+        description: "The ssh wait timeout, before attempting ssh",
+        default: "0"
 
       option :retry_ssh_every,
-        :long => "--retry-ssh-every TIMEOUT",
-        :description => "Retry SSH after n seconds (retry each period)",
-        :default => "5"
+        long: "--retry-ssh-every TIMEOUT",
+        description: "Retry SSH after n seconds (retry each period)",
+        default: "5"
 
       option :retry_ssh_limit,
-        :long => "--retry-ssh-limit COUNT",
-        :description => "Retry SSH at most this number of times",
-        :default => "5"
+        long: "--retry-ssh-limit COUNT",
+        description: "Retry SSH at most this number of times",
+        default: "5"
 
       option :default_networks,
-        :long => "--[no-]default-networks",
-        :description => "Include public and service networks, enabled by default",
-        :boolean => true,
-        :default => true
+        long: "--[no-]default-networks",
+        description: "Include public and service networks, enabled by default",
+        boolean: true,
+        default: true
 
       option :network,
-        :long => "--network [LABEL_OR_ID]",
-        :description => "Add private network. Use multiple --network options to specify multiple networks.",
-        :proc => Proc.new{ |name|
+        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] ||= []
           (Chef::Config[:knife][:rackspace_networks] << name).uniq!
         }
 
       option :bootstrap_protocol,
-        :long => "--bootstrap-protocol protocol",
-        :description => "Protocol to bootstrap Windows servers. options: winrm",
-        :default => nil
+        long: "--bootstrap-protocol protocol",
+        description: "Protocol to bootstrap Windows servers. options: winrm",
+        default: nil
 
       option :server_create_timeout,
-        :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 }
+        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 }
 
       option :bootstrap_proxy,
-        :long => "--bootstrap-proxy PROXY_URL",
-        :description => "The proxy server for the node being bootstrapped",
-        :proc => Proc.new { |v| Chef::Config[:knife][:bootstrap_proxy] = v }
+        long: "--bootstrap-proxy PROXY_URL",
+        description: "The proxy server for the node being bootstrapped",
+        proc: Proc.new { |v| Chef::Config[:knife][:bootstrap_proxy] = v }
 
       option :rackspace_disk_config,
-        :long => "--rackspace-disk-config DISKCONFIG",
-        :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 }
+        long: "--rackspace-disk-config DISKCONFIG",
+        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",
-        :description => "Creates a config drive device in /dev/disk/by-label/config-2 if set to TRUE",
-        :proc => Proc.new { |k| Chef::Config[:knife][:rackspace_config_drive] = k },
-        :default => "false"
+        long: "--rackspace_config_drive CONFIGDRIVE",
+        description: "Creates a config drive device in /dev/disk/by-label/config-2 if set to TRUE",
+        proc: Proc.new { |k| Chef::Config[:knife][:rackspace_config_drive] = k },
+        default: "false"
 
       option :rackspace_user_data_file,
-        :long => "--rackspace_user_data_file USERDATA",
-        :description => "User data file will be placed in the openstack/latest/user_data directory on the config drive",
-        :proc => Proc.new { |k| Chef::Config[:knife][:rackspace_user_data] = k }
+        long: "--rackspace_user_data_file USERDATA",
+        description: "User data file will be placed in the openstack/latest/user_data directory on the config drive",
+        proc: Proc.new { |k| Chef::Config[:knife][:rackspace_user_data] = k }
 
       option :ssh_keypair,
-        :long => "--ssh-keypair KEYPAIR_NAME",
-        :description => "Name of existing nova SSH keypair. Public key will be injected into the instance.",
-        :proc => Proc.new { |v| Chef::Config[:knife][:rackspace_ssh_keypair] = v },
-        :default => nil
+        long: "--ssh-keypair KEYPAIR_NAME",
+        description: "Name of existing nova SSH keypair. Public key will be injected into the instance.",
+        proc: Proc.new { |v| Chef::Config[:knife][:rackspace_ssh_keypair] = v },
+        default: nil
+
+      option :secret,
+        long: "--secret",
+        description: "The secret key to us to encrypt data bag item values",
+        proc: lambda { |s| Chef::Config[:knife][:secret] = s }
 
       option :secret_file,
-        :long => "--secret-file SECRET_FILE",
-        :description => "A file containing the secret key to use to encrypt data bag item values",
-        :proc => Proc.new { |sf| Chef::Config[:knife][:secret_file] = sf }
+        long: "--secret-file SECRET_FILE",
+        description: "A file containing the secret key to use to encrypt data bag item values",
+        proc: lambda { |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",
-        :description => 'A single vault and item to update as "vault:item"',
-        :proc        => Proc.new { |i|
+        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(/:/)
           Chef::Config[:knife][:bootstrap_vault_item] ||= {}
           Chef::Config[:knife][:bootstrap_vault_item][vault] ||= []
@@ -284,20 +300,19 @@ class Chef
 
       def load_winrm_deps
         require "winrm"
-        require "em-winrm"
+        require "chef/knife/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 locate_config_value(:tcp_test_ssh) != nil
+        return true if locate_config_value(:tcp_test_ssh).nil?
 
         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
@@ -343,16 +358,16 @@ class Chef
           dest, src = parse_file_argument(arg)
           Chef::Log.debug("Inject file #{src} into #{dest}")
           files << {
-            :path => dest,
-            :contents => encode_file(src),
+            path: dest,
+            contents: encode_file(src),
           }
         end
         files
       end
 
       def tcp_test_winrm(hostname, port)
-        TCPSocket.new(hostname, port)
-        return true
+        tcp_socket = TCPSocket.new(hostname, port)
+        true
       rescue SocketError
         sleep 2
         false
@@ -369,20 +384,21 @@ class Chef
       rescue Errno::ENETUNREACH
         sleep 2
         false
+        tcp_socket && tcp_socket.close
       end
 
       def run
         $stdout.sync = true
 
         server_create_options = {
-          :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 => locate_config_value(:rackspace_ssh_keypair),
-          :name => get_node_name(config[:chef_node_name] || config[:server_name]),
-          :networks => get_networks(locate_config_value(:rackspace_networks), locate_config_value(:rackconnect_v3_network_id)),
+          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: locate_config_value(:rackspace_ssh_keypair),
+          name: get_node_name(config[:chef_node_name] || config[:server_name]),
+          networks: get_networks(locate_config_value(:rackspace_networks), locate_config_value(:rackconnect_v3_network_id)),
         }
 
         # Maybe deprecate this option at some point
@@ -415,7 +431,7 @@ class Chef
         else
           server_create_options[:image_id] = locate_config_value(:image)
 
-          if !server_create_options[:image_id]
+          unless server_create_options[:image_id]
             ui.error("Please specify an Image ID for the server with --image (-I)")
             exit 1
           end
@@ -430,7 +446,7 @@ class Chef
         if version_one?
           server.save
         else
-          server.save(:networks => server_create_options[:networks])
+          server.save(networks: server_create_options[:networks])
         end
 
         rackconnect_wait = locate_config_value(:rackconnect_wait)
@@ -453,18 +469,18 @@ class Chef
         # wait for it to be ready to do stuff
         begin
           server.wait_for(Integer(locate_config_value(:server_create_timeout))) do
-            print ".";
+            print "."
             Chef::Log.debug("#{progress}%")
 
             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']}")
+              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? && 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']}")
+              Chef::Log.debug("rackconnect_automation_status: #{metadata.all["rackconnect_automation_status"]}")
               ready? && metadata.all["rackconnect_automation_status"] == "DEPLOYED"
             elsif rackspace_servicelevel_wait
-              Chef::Log.debug("rax_service_level_automation: #{metadata.all['rax_service_level_automation']}")
+              Chef::Log.debug("rax_service_level_automation: #{metadata.all["rax_service_level_automation"]}")
               ready? && metadata.all["rax_service_level_automation"] == "Complete"
             else
               ready?
@@ -475,7 +491,7 @@ class Chef
           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'
+          Chef::Application.fatal! "Server didn't finish on time"
         end
 
         msg_pair("Metadata", server.metadata)
@@ -584,7 +600,6 @@ class Chef
         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 locate_config_value(:ssh_user) == "root"
-        bootstrap.config[:distro] = locate_config_value(:distro) || "chef-full"
         bootstrap_common_params(bootstrap, server)
       end
 
@@ -598,14 +613,13 @@ class Chef
         end
         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[:bootstrap_template] = locate_config_value(:bootstrap_template)
         bootstrap.config[:first_boot_attributes] = locate_config_value(:first_boot_attributes)
         bootstrap.config[:bootstrap_proxy] = locate_config_value(:bootstrap_proxy)
-#        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[:encrypted_data_bag_secret] = locate_config_value(:secret)
+        bootstrap.config[:encrypted_data_bag_secret_file] = locate_config_value(: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"] ||= {}
@@ -624,10 +638,11 @@ class Chef
       end
 
     end
-    #v2 servers require a name, random if chef_node_name is empty, empty if v1
+    # v2 servers require a name, random if chef_node_name is empty, empty if v1
     def get_node_name(chef_node_name)
       return chef_node_name unless chef_node_name.nil?
-      #lazy uuids
+
+      # lazy uuids
       chef_node_name = "rs-" + rand.to_s.split(".")[1] unless version_one?
     end
 
@@ -638,10 +653,10 @@ class Chef
         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",
-                 ]
+                 %w{
+                   00000000-0000-0000-0000-000000000000
+                   11111111-1111-1111-1111-111111111111
+                 }
                else
                  []
                end