knife-rackspace 0.11.0 → 0.11.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    M2NhZmI1NDM4OWUxODEwODI1ZGVmNWQ2YzgxZjBjNmJiYjMzOGVkYQ==
+    ODQzY2Q3NmUyODY1YmQ0OTUyN2Q5NjI1N2I3MTBmMDYxOGVkY2Y5MQ==
   data.tar.gz: !binary |-
-    OTY4MTM0MTMzNzY5M2U4NWUwMmMxNmFhZWEyNjQ3YjQzYTdkNWMwZA==
+    MjY0YmQ3N2VhYTA4MjZiNmI1ZDAyZDJjMzMwMzQyYzI3ODdkZDcyOQ==
 SHA512:
   metadata.gz: !binary |-
-    NTdjN2ZlMzBiNjUwZDZjODQ0M2U1YmQyODkwMTA0MGMyMTIxYjZmYTNhODQ5
-    MGExY2U5NmEzMzc5MTUxMWE4YzkwZDBiMGJmNzMxZTAyODc2MzZmMjdiMjg1
-    NzVlMWU0NWZlYjY1Yzc5MDU2OWE4MjI4NGUxMjM4N2I5MGFjZjQ=
+    YTJlMjM3ZThmZWJhYjQ3NTlkYjYzZGJjZjQ2YTQ4ZmQ2ZTMyYjZhMTU4N2Ux
+    NmZmOTIxMjhkYzNjYjM2ZDJmZjZjZGYyY2M2NTk4NDliM2QxMTY2ODRiYTQ1
+    YTExNmFhNGI5NzI2NTQ2NDhlMThlNjgxMWIzYTdlNTIzMGRmMDY=
   data.tar.gz: !binary |-
-    YTVkNjkwMjM4MDM0YTZhZDdjNmEzZDhlYzY2OTk4NTA3MTdmODE2YjgyNzRj
-    MzJjODA0MjY1MmFhNjY5NzFmMWFhMzY4YjhlZjQ4OTA1MTkwNGRlMjBiZTc4
-    Mzk4MjE1OGU3ODkyOTM3NDJmMWQ1ZDcxYWQ5MGY4YjI4ZTdjN2E=
+    NGJiY2NiOTNiN2QzOGUxNmRkN2RlYjA0MTVmZGJmOWQ2NzA1ODBmZTEwNWI2
+    NDliY2I2ODRlMGE5NWM3OGFlZGY4ZDZjZjNhOWNiMjdmMDMyNDI3ZTRmZjhk
+    NWYzMDMyNDYwZDc1MWFiMDkwMjI2ZjgyMjJlNTczMDJkMDVmYzI=

data/.travis.yml

@@ -1,3 +1,4 @@
+sudo: false
 language: ruby
 rvm:
   - 2.2

data/knife-rackspace.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.has_rdoc = true
   s.authors     = ["Adam Jacob","Seth Chisamore", "Matt Ray","Rackspace Developers","JJ Asghar"]
   s.email       = ["adam@chef.io","schisamo@chef.io", "matt@chef.io","jj@chef.io"]
-  s.homepage = "https://docs.chef.io/plugin_knife_rackspace.html"
+  s.homepage = "https://github.com/chef/knife-rackspace"
   s.summary = "Rackspace Support for Chef's Knife Command"
   s.description = s.summary
   s.extra_rdoc_files = ["README.rdoc", "LICENSE" ]
@@ -17,11 +17,10 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.add_dependency "knife-windows"
-  s.add_dependency "fog", '>= 1.24'
-  s.add_dependency "chef", ">= 0.10.10"
+  s.add_dependency "fog", '>= 1.35'
+  s.add_dependency "chef", ">= 11.0.0"
   s.require_paths = ["lib"]
 
-  s.add_development_dependency "knife-dsl"
   s.add_development_dependency "rspec"
   s.add_development_dependency "vcr"
   s.add_development_dependency "ansi"

data/lib/chef/knife/rackspace_base.rb

@@ -77,14 +77,17 @@ class Chef
       def connection
         Chef::Log.debug("version #{Chef::Config[:knife][:rackspace_version]} (config)")
         Chef::Log.debug("version #{config[:rackspace_version]} (cli)")
-        Chef::Log.debug("rackspace_api_key #{Chef::Config[:knife][:rackspace_api_key]}")
-        Chef::Log.debug("rackspace_username #{Chef::Config[:knife][:rackspace_username]}")
-        Chef::Log.debug("rackspace_api_username #{Chef::Config[:knife][:rackspace_api_username]}")
-        Chef::Log.debug("rackspace_auth_url #{Chef::Config[:knife][:rackspace_auth_url]}")
-        Chef::Log.debug("rackspace_auth_url #{config[:rackspace_api_auth_url]}")
+        Chef::Log.debug("rackspace_api_key #{Chef::Config[:knife][:rackspace_api_key]} (config)")
+        Chef::Log.debug("rackspace_api_key #{config[:rackspace_api_key]} (cli)")
+        Chef::Log.debug("rackspace_username #{Chef::Config[:knife][:rackspace_username]} (config)")
+        Chef::Log.debug("rackspace_username #{config[:rackspace_username]} (cli)")
+        Chef::Log.debug("rackspace_api_username #{Chef::Config[:knife][:rackspace_api_username]} (config)")
+        Chef::Log.debug("rackspace_api_username #{config[:rackspace_api_username]} (cli)")
+        Chef::Log.debug("rackspace_auth_url #{Chef::Config[:knife][:rackspace_auth_url]} (config)")
+        Chef::Log.debug("rackspace_auth_url #{config[:rackspace_api_auth_url]} (cli)")
         Chef::Log.debug("rackspace_auth_url #{auth_endpoint} (using)")
-        Chef::Log.debug("rackspace_region #{Chef::Config[:knife][:rackspace_region]}")
-        Chef::Log.debug("rackspace_region #{config[:rackspace_region]}")
+        Chef::Log.debug("rackspace_region #{Chef::Config[:knife][:rackspace_region]} (config)")
+        Chef::Log.debug("rackspace_region #{config[:rackspace_region]} (cli)")
 
         if version_one?
           Chef::Log.debug("rackspace v1")
@@ -105,7 +108,7 @@ class Chef
       end
 
       def region_warning_for_v1
-        if Chef::Config[:knife][:rackspace_region] || config[:rackspace_region]
+        if locate_config_value(:rackspace_region)
           Chef::Log.warn("Ignoring the rackspace_region parameter as it is only supported for Next Gen Cloud Servers (v2)")
         end
       end
@@ -116,10 +119,21 @@ class Chef
           exit 1
         end
 
+        username =  locate_config_value(:rackspace_username) || locate_config_value(:rackspace_api_username)
+        unless username
+          ui.error "Please specify an api username via the command line using the --rackspace-username switch or add a knife[:rackspace_username] = USERNAME to your knife file."
+          exit 1
+        end
+
+        unless locate_config_value(:rackspace_api_key)
+          ui.error "Please specify an api key via the command line using the --rackspace-api-key switch or add a knife[:rackspace_api_key] = USERNAME to your knife file."
+          exit 1
+        end
+
         hash = options.merge({
           :provider => 'Rackspace',
-          :rackspace_api_key => Chef::Config[:knife][:rackspace_api_key],
-          :rackspace_username => (Chef::Config[:knife][:rackspace_username] || Chef::Config[:knife][:rackspace_api_username]),
+          :rackspace_api_key => locate_config_value(:rackspace_api_key),
+          :rackspace_username => username,
           :rackspace_auth_url => auth_endpoint,
           :rackspace_region => locate_config_value(:rackspace_region)
         })

data/lib/chef/knife/rackspace_server_create.rb

@@ -54,6 +54,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",
@@ -106,7 +112,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 +150,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",
@@ -232,9 +239,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",
@@ -286,9 +292,9 @@ class Chef
       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
@@ -301,7 +307,7 @@ class Chef
 
           if count <= limit
             print '.'
-            sleep config[:retry_ssh_every].to_i
+            sleep locate_config_value(:retry_ssh_every).to_i
             tcp_test_ssh(server, bootstrap_ip)
           else
             ui.error "Unable to SSH into #{bootstrap_ip}"
@@ -372,18 +378,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)
@@ -401,15 +407,16 @@ class Chef
         # 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[: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)')
@@ -429,8 +436,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,11 +447,11 @@ 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("UserData", locate_config_value(: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("RackConnect V3", locate_config_value(: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("SSH Key", locate_config_value(:rackspace_ssh_keypair))
 
         # wait for it to be ready to do stuff
         begin
@@ -480,7 +487,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,8 +496,8 @@ 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))
@@ -499,7 +506,7 @@ class Chef
         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?
@@ -554,7 +561,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,16 +577,16 @@ 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[: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,13 +599,14 @@ 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)  || ""
 
@@ -629,16 +637,16 @@ class Chef
     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 = [
+      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
-          nets  = []
+          []
         end
 
         available_networks = connection.networks.all

data/lib/chef/knife/rackspace_server_delete.rb

@@ -67,6 +67,7 @@ class Chef
             msg_pair("Name", server.name)
             msg_pair("Flavor", server.flavor.name)
             msg_pair("Image", server.image.name) if server.image
+            msg_pair("Boot Image ID", server.boot_image_id) if server.boot_image_id
             msg_pair("Public IP Address", ip_address(server, 'public'))
             msg_pair("Private IP Address", ip_address(server, 'private'))
 

data/lib/knife-rackspace/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Rackspace
-    VERSION = '0.11.0'
+    VERSION = '0.11.1'
     MAJOR, MINOR, TINY = VERSION.split('.')
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-rackspace
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Adam Jacob
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-08 00:00:00.000000000 Z
+date: 2016-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: knife-windows
@@ -34,42 +34,28 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '1.24'
+        version: '1.35'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '1.24'
+        version: '1.35'
 - !ruby/object:Gem::Dependency
   name: chef
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.10.10
+        version: 11.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.10.10
-- !ruby/object:Gem::Dependency
-  name: knife-dsl
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: 11.0.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -165,7 +151,7 @@ files:
 - spec/integration_spec_helper.rb
 - spec/spec_helper.rb
 - spec/unit/rackspace_base_spec.rb
-homepage: https://docs.chef.io/plugin_knife_rackspace.html
+homepage: https://github.com/chef/knife-rackspace
 licenses: []
 metadata: {}
 post_install_message: