knife-rackspace 2.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3799ca445b0f7ba27563c830cbf6650a780c57a46807431c342a100924d9167e
-  data.tar.gz: 9d2580b66da6812bcad820e2eb11f3ea4c07eaf792166949dff98d518421d03d
+  metadata.gz: 4d076b1123a47563c50cc2113b132fcad24792de369fefda5d879af3def6b6fb
+  data.tar.gz: 55fb1c587e13f2a029783891c9cce1585e120fb6f3eb9df2fe5779775fd44982
 SHA512:
-  metadata.gz: 96e95c86c1f6d6081ad501a9a8c47d0d2fefb3e26937cc2af73ebdd31f52ac3bc53c514dbb6bc2110a3756504de75502b7acd74b05dc06aac420eadbd690ce49
-  data.tar.gz: 4ac56dd985fd2fda28c1117c99c63e31bb440e498a728ffc52be9c90279f06741cae50236294341cb848a1c7ef51810ec43c350989dc1df6c6424c378c516759
+  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,256 +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. [DEPRECATED] Use -t / --bootstrap-template option instead.",
-        :proc        => Proc.new { |v|
+        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. [DEPRECATED] Use -t / --bootstrap-template option instead.",
-        :proc        => Proc.new { |v|
+        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."
+        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 }
+        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 => lambda { |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] ||= []
@@ -306,13 +306,13 @@ class Chef
       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
@@ -358,8 +358,8 @@ 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
@@ -391,14 +391,14 @@ class Chef
         $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
@@ -431,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
@@ -446,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)
@@ -469,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?
@@ -491,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)
@@ -638,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
 
@@ -652,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

data/lib/chef/knife/rackspace_server_delete.rb

@@ -17,7 +17,7 @@
 # limitations under the License.
 #
 
-require "chef/knife/rackspace_base"
+require_relative "rackspace_base"
 
 # These two are needed for the '--purge' deletion case
 require "chef/node"
@@ -32,16 +32,16 @@ class Chef
       banner "knife rackspace server delete SERVER_ID [SERVER_ID] (options)"
 
       option :purge,
-        :short => "-P",
-        :long => "--purge",
-        :boolean => true,
-        :default => false,
-        :description => "Destroy corresponding node and client on the Chef Server, in addition to destroying the Rackspace node itself. Assumes node and client have the same name as the server (if not, add the '--node-name' option)."
+        short: "-P",
+        long: "--purge",
+        boolean: true,
+        default: false,
+        description: "Destroy corresponding node and client on the Chef Server, in addition to destroying the Rackspace node itself. Assumes node and client have the same name as the server (if not, add the '--node-name' option)."
 
       option :chef_node_name,
-        :short => "-N NAME",
-        :long => "--node-name NAME",
-        :description => "The name of the node and client to delete, if it differs from the server name. Only has meaning when used with the '--purge' option."
+        short: "-N NAME",
+        long: "--node-name NAME",
+        description: "The name of the node and client to delete, if it differs from the server name. Only has meaning when used with the '--purge' option."
 
       # Extracted from Chef::Knife.delete_object, because it has a
       # confirmation step built in... By specifying the '--purge'
@@ -49,13 +49,11 @@ class Chef
       # the user is already making their intent known.  It is not
       # necessary to make them confirm two more times.
       def destroy_item(klass, name, type_name)
-        begin
-          object = klass.load(name)
-          object.destroy
-          ui.warn("Deleted #{type_name} #{name}")
-        rescue Net::HTTPServerException
-          ui.warn("Could not find a #{type_name} named #{name} to delete!")
-        end
+        object = klass.load(name)
+        object.destroy
+        ui.warn("Deleted #{type_name} #{name}")
+      rescue Net::HTTPServerException
+        ui.warn("Could not find a #{type_name} named #{name} to delete!")
       end
 
       def run
@@ -84,7 +82,7 @@ class Chef
                 destroy_item(Chef::Node, thing_to_delete, "node")
                 destroy_item(Chef::ApiClient, thing_to_delete, "client")
               else
-                #v2 nodes may be named automatically
+                # v2 nodes may be named automatically
                 thing_to_delete = config[:chef_node_name] || server.name
                 destroy_item(Chef::Node, thing_to_delete, "node")
                 destroy_item(Chef::ApiClient, thing_to_delete, "client")

data/lib/chef/knife/rackspace_server_list.rb

@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require "chef/knife/rackspace_base"
+require_relative "rackspace_base"
 
 class Chef
   class Knife
@@ -39,7 +39,7 @@ class Chef
         if version_one?
           network_list = %w{public private}
         else
-          network_list = connection.networks.sort_by(&:label).collect { |t| t.label }
+          network_list = connection.networks.sort_by(&:label).collect(&:label)
         end
         server_list.insert(2, network_list.collect { |n| ui.color("#{n.capitalize} IP", :bold) }).flatten!
         num_columns_across = server_list.length
@@ -48,8 +48,8 @@ class Chef
           server_list << server.id.to_s
           server_list << server.name
           server_list += network_list.collect { |n| ip_address(server, n) }
-          server_list << (server.flavor_id == nil ? "" : server.flavor_id.to_s)
-          server_list << (server.image_id == nil ? "" : server.image_id.to_s)
+          server_list << (server.flavor_id.nil? ? "" : server.flavor_id.to_s)
+          server_list << (server.image_id.nil? ? "" : server.image_id.to_s)
           server_list << begin
             case server.state.downcase
             when "deleted", "suspended"

data/lib/knife-rackspace/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Rackspace
-    VERSION = "2.0.0"
+    VERSION = "2.0.2".freeze
     MAJOR, MINOR, TINY = VERSION.split(".")
   end
 end

data/spec/integration_spec_helper.rb

@@ -3,8 +3,8 @@ require "vcr"
 require "ansi/code"
 require "ansi/diff"
 
-Chef::Config[:knife][:rackspace_api_username] = "#{ENV['OS_USERNAME']}"
-Chef::Config[:knife][:rackspace_api_key] = "#{ENV['OS_PASSWORD']}"
+Chef::Config[:knife][:rackspace_api_username] = "#{ENV["OS_USERNAME"]}"
+Chef::Config[:knife][:rackspace_api_key] = "#{ENV["OS_PASSWORD"]}"
 Chef::Config[:knife][:ssl_verify_peer] = false
 # Chef::Config[:knife][:rackspace_version] = "#{ENV['RS_VERSION']}"
 
@@ -45,9 +45,9 @@ VCR.configure do |c|
   c.default_cassette_options = {
     # :record => :none,
     # Ignores cache busting parameters.
-    :match_requests_on => [:host, :path],
+    match_requests_on: %i{host path},
   }
-  c.default_cassette_options.merge!({ :record => :all }) if ENV["INTEGRATION_TESTS"] == "live"
+  c.default_cassette_options.merge!({ record: :all }) if ENV["INTEGRATION_TESTS"] == "live"
 end
 
 def filter_headers(interaction, pattern, placeholder)
@@ -124,7 +124,7 @@ def knife_capture(command, args = [], input = nil)
   $VERBOSE = warn
 
   status = Chef::Knife::DSL::Support.run_knife(command, args)
-  return $stdout.string, $stderr.string, status
+  [$stdout.string, $stderr.string, status]
 ensure
   warn = $VERBOSE
   $VERBOSE = nil

data/spec/unit/rackspace_base_spec.rb

@@ -18,7 +18,7 @@ describe "auth_endpoint" do
     expect(tester.auth_endpoint).to eq(test_url)
   end
 
-  [:dfw, :ord, :syd].each do |region|
+  %i{dfw ord syd}.each do |region|
     it "should pick the US endpoint if the region is #{region}" do
       tester = RackspaceBaseTester.new
       Chef::Config[:knife][:rackspace_auth_url] = nil
@@ -38,7 +38,7 @@ describe "auth_endpoint" do
 end
 
 describe "locate_config_value" do
-  it 'with cli options' do
+  it "with cli options" do
     # CLI
     tester = RackspaceBaseTester.new
     tester.parse_options([ "--rackspace-api-key", "12345" ])
@@ -50,7 +50,7 @@ describe "locate_config_value" do
     expect(tester.locate_config_value(:rackspace_api_key)).to eq("12345")
   end
 
-  it 'without cli options' do
+  it "without cli options" do
     # CLI
     tester = RackspaceBaseTester.new
     tester.parse_options([])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-rackspace
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.2
 platform: ruby
 authors:
 - Adam Jacob
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-28 00:00:00.000000000 Z
+date: 2019-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: knife-windows
@@ -104,8 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Rackspace Support for Chef's Knife Command