knife-rackspace 0.7.0 → 0.8.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ODUxNTU1NTRiNTE4MDg2MTczMDM3YmRjN2Q5ZGQyN2M0NWZiZDA4OA==
+  data.tar.gz: !binary |-
+    OWJlMTYxZjM0MTJiYmYxYzFjNTQ1NjRkNWVkM2U4MTY4ZTJiYTQ2Mw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NGFhYjRmNzY0ZDRlMTNkMGU3YTA2MTFjN2ZlYWQ0ZDRmZmQzNjYzYjY4NTI1
+    ZTQ3OTZmOTA3ZTcxMDMzODA5MzVhOGFiMjhiYjkwNjYzYzVhYTA1ZmQzMzEx
+    NWZjZGU4NjkxMzA5ZWRjMzFhNWIwZTJiZDUxNTNiNWFlYTY4Y2U=
+  data.tar.gz: !binary |-
+    MWJmZWQwMzIzZWJmZGM5NDU1ZDk1NGVmZTAxOTkwNTRlNmVkYjM3Y2E5NmJl
+    MzkwNjBhMDhjOGI4OTJhNDg5YWNhZGI5NmUxMTQ3YzgxZWY3YzI3MGU5Y2M3
+    YjdmODdlYzc4OWViYTZmNzdiMzVkZTg4MjMwNzg3NTg3YmZiY2E=

data/.travis.yml

@@ -3,7 +3,6 @@ language: ruby
 rvm:
 - 2.0.0
 - 1.9.3
-- 1.8.7
 env:
   global:
   - secure: ! 'eEsikE/p2yz7/cFvCN/NOoljxBqjzsTWnKC7iZ+fEGGsyhKVJgWn4AasBusZ

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## v0.8.0
+* KNIFE-68 enable ability to modify ssh port number
+* KNIFE-180 include option to pass :disk_config option to fog for new node bootstrap
+* KNIFE-312 updated to reflect new configuration options in Fog 1.10.1
+* KNIFE-314 provisioning First Gen Cloud Server is broken
+* KNIFE-315 fixed DEPRECATION warnings related to use of old rackpace_auth_url and removed rackspace_endpoint
+
 ## v0.7.0
 * KNIFE_RACKSPACE-32 Ensure hint file is created to improve Ohai detection.
 * KNIFE-181 correct mixed use of 'rackspace_auth_url' and 'rackspace_api_auth_url'. Only 'rackspace_auth_url' is correct.

data/README.rdoc

@@ -16,6 +16,17 @@ This plugin is distributed as a Ruby Gem. To install it, run:
 
 Depending on your system's configuration, you may need to run this command with root privileges.
 
+Ensure only the latest knife-rackspace gem and no other is installed.  In some cases having older versions of the gem
+will cause the new OpenStack functionality not to function properly.  To check:
+
+    $> gem list --local | grep knife-rackspace
+    knife-rackspace (0.6.2, 0.5.12)
+    $> gem uninstall knife-rackspace -v "= 0.5.12"
+    Successfully uninstalled knife-rackspace-0.5.12
+    $> gem list --local | grep knife-rackspace
+    knife-rackspace (0.6.2)
+
+
 = CONFIGURATION:
 
 In order to communicate with the Rackspace Cloud API you will have to tell Knife about your Username and API Key. The easiest way to accomplish this is to create some entries in your <tt>knife.rb</tt> file:
@@ -37,28 +48,22 @@ To select for the previous Rackspace API (aka 'v1'), you can use the <tt>--racks
 
     knife[:rackspace_version] = 'v1'
 
-This plugin also has support for authenticating against an alternate API Auth URL. This is useful if you are a Rackspace Cloud UK user, here is an example of configuring your <tt>knife.rb</tt>:
+This plugin also has support for authenticating against an alternate API Auth URL. This is useful if you are a using a custom endpoint, here is an example of configuring your <tt>knife.rb</tt>:
 
-    knife[:rackspace_auth_url] = "lon.auth.api.rackspacecloud.com"
+    knife[:rackspace_auth_url] = "auth.my-custom-endpoint.com"
 
-This plugin also has support for specifying which region to create servers into:
 
-    knife[:rackspace_endpoint] = "https://dfw.servers.api.rackspacecloud.com/v2"
-
-valid options include:
-      DFW_ENDPOINT = 'https://dfw.servers.api.rackspacecloud.com/v2'
-      ORD_ENDPOINT = 'https://ord.servers.api.rackspacecloud.com/v2'
-      LON_ENDPOINT = 'https://lon.servers.api.rackspacecloud.com/v2'
+Different regions can be specified by using the `--rackspace-region` switch or using the `knife[:rackspace_region]` in the knife.rb file. Valid regions include :dfw, :ord, :lon, and :syd.
 
 If you are behind a proxy you can specify it in the knife.rb file as follows:
 
-	https_proxy https://PROXY_IP_ADDRESS:PORT
+    https_proxy https://PROXY_IP_ADDRESS:PORT
 
 SSL certificate verification can be disabled by include the following in your knife.rb file:
 
-	knife[:ssl_verify_peer] = false
+    knife[:ssl_verify_peer] = false
 
-Additionally the following options may be set in your `knife.rb`:
+Additionally the following options may be set in your <tt>knife.rb</tt>:
 
 * flavor
 * image
@@ -81,22 +86,39 @@ Files can be injected onto the provisioned system using the <tt>--file</tt> swit
 
 Note: You can only inject text files and the maximum destination path is 255 characters.
 
+You may specify if want to manage your disk partitioning scheme with the <tt>--rackspace-disk-config DISKCONFIG</tt> option. If you bootstrap a `v2` node and leave this set to the default "AUTO", larger nodes take longer to bootstrap as it grows the disk from 10G to fill the full amount of local disk provided. This option allows you to pass "MANUAL" - which give you a node (in 1/2 to 1/4 of the time) and lets you manage ignoring, or formatting the rest of the disk on your own.
+
+http://docs.openstack.org/essex/openstack-compute/starter/content/Launch_and_manage_instances-d1e1885.html
+
+You may specify a custom network using the <tt>--network [LABEL_OR_ID]</tt> option. You can also remove the default internal ServiceNet and PublicNet networks by specifying the <tt>--no-default-networks</tt> switch.
+
 == knife rackspace server delete
 
-Deletes an existing server in the currently configured Rackspace Cloud account by the server/instance id. You can find the instance id by entering 'knife rackspace server list'. Please note - this does not delete the associated node and client objects from the Chef server unless you pass the <tt>-P</tt> or <tt>--purge</tt> command option. Using the <tt>--purge</tt> option with v2 nodes will attempt to delete the node and client by the name of the node.
+Deletes an existing server in the currently configured Rackspace Cloud account by the server/instance id. You can find the instance id by entering <tt>knife rackspace server list</tt>. Please note - this does not delete the associated node and client objects from the Chef server unless you pass the <tt>-P</tt> or <tt>--purge</tt> command option. Using the <tt>--purge</tt> option with v2 nodes will attempt to delete the node and client by the name of the node.
 
 == knife rackspace server list
 
-Outputs a list of all servers in the currently configured Rackspace Cloud account. Please note - this shows all instances associated with the account, some of which may not be currently managed by the Chef server. You may need to use the <tt>--rackspace-version</tt> and possibly a <tt>--rackspace-endpoint</tt> options to see nodes in different Rackspace regions.
+Outputs a list of all servers in the currently configured Rackspace Cloud account. Please note - this shows all instances associated with the account, some of which may not be currently managed by the Chef server. You may need to use the <tt>--rackspace-version</tt> and <tt>--rackspace-region</tt> options to see nodes in different Rackspace regions.
 
 == knife rackspace flavor list
 
-Outputs a list of all available flavors (available hardware configuration for a server) available to the currently configured Rackspace Cloud account. Each flavor has a unique combination of disk space, memory capacity and priority for CPU time. This data can be useful when choosing a flavor id to pass to the <tt>knife rackspace server create</tt> subcommand. You may need to use the <tt>--rackspace-version</tt> and possibly a <tt>--rackspace-endpoint</tt> options to see nodes in different Rackspace regions.
+Outputs a list of all available flavors (available hardware configuration for a server) available to the currently configured Rackspace Cloud account. Each flavor has a unique combination of disk space, memory capacity and priority for CPU time. This data can be useful when choosing a flavor id to pass to the <tt>knife rackspace server create</tt> subcommand. You may need to use the <tt>--rackspace-version</tt> and <tt>--rackspace-region</tt> options to see nodes in different Rackspace regions.
 
 == knife rackspace image list
 
-Outputs a list of all available images available to the currently configured Rackspace Cloud account. An image is a collection of files used to create or rebuild a server. Rackspace provides a number of pre-built OS images by default. This data can be useful when choosing an image id to pass to the <tt>knife rackspace server create</tt> subcommand. You may need to use the <tt>--rackspace-version</tt> and possibly a <tt>--rackspace-endpoint</tt> options to see nodes in different Rackspace regions.
+Outputs a list of all available images available to the currently configured Rackspace Cloud account. An image is a collection of files used to create or rebuild a server. Rackspace provides a number of pre-built OS images by default. This data can be useful when choosing an image id to pass to the <tt>knife rackspace server create</tt> subcommand. You may need to use the <tt>--rackspace-version</tt> and <tt>--rackspace-region</tt> options to see nodes in different Rackspace regions.
+
+== knife rackspace network list
+
+Outputs a list of available networks to the currently configured Rackspace Cloud account. Networks can be added at a server during the creation process using the <tt>--network [LABEL_OR_ID]</tt> option. Knife does not currently support adding a network to an existing server.
+
+== knife rackspace network create
+
+Creates a new cloud network. Both the label and the CIDR are required parameters which are specified using the <tt>--label LABEL</tt>  and <tt>--cidr CIDR</tt> respectively. The CIDR should be in the form of 172.16.0.0/24 or 2001:DB8::/64. Refer to http://www.rackspace.com/knowledge_center/article/using-cidr-notation-in-cloud-networks for more information.
+
+== knife rackspace network delete
 
+Deletes one or more specified networks by id. The network must be detached from all hosts before it is deleted.
 
 = LICENSE:
 

data/knife-rackspace.gemspec

@@ -16,8 +16,8 @@ Gem::Specification.new do |s|
   s.files         = `git ls-files`.split("\n")
   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 "fog", "~> 1.6"
   s.add_dependency "knife-windows"
+  s.add_dependency "fog", "~> 1.12"
   s.add_dependency "chef", ">= 0.10.10"
   s.require_paths = ["lib"]
 

data/lib/chef/knife/rackspace_base.rb

@@ -17,6 +17,7 @@
 #
 
 require 'chef/knife'
+require 'fog'
 
 class Chef
   class Knife
@@ -56,14 +57,13 @@ class Chef
           option :rackspace_auth_url,
             :long => "--rackspace-auth-url URL",
             :description => "Your rackspace API auth url",
-            :default => "auth.api.rackspacecloud.com",
             :proc => Proc.new { |url| Chef::Config[:knife][:rackspace_auth_url] = url }
 
-          option :rackspace_endpoint,
-            :long => "--rackspace-endpoint URL",
-            :description => "Your rackspace API endpoint",
-            :default => "https://dfw.servers.api.rackspacecloud.com/v2",
-            :proc => Proc.new { |url| Chef::Config[:knife][:rackspace_endpoint] = url }
+          option :rackspace_region,
+            :long => "--rackspace-region REGION",
+            :description => "Your rackspace region",
+            :default => "dfw",
+            :proc => Proc.new { |region| Chef::Config[:knife][:rackspace_region] = region }
 
           option :file,
             :long => '--file DESTINATION-PATH=SOURCE-PATH',
@@ -81,12 +81,15 @@ class Chef
         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]} (config)")
-        Chef::Log.debug("rackspace_auth_url #{config[:rackspace_auth_url]} (cli)")
-        Chef::Log.debug("rackspace_endpoint #{Chef::Config[:knife][:rackspace_endpoint]} (config)")
-        Chef::Log.debug("rackspace_endpoint #{config[:rackspace_endpoint]} (cli)")
-        if (Chef::Config[:knife][:rackspace_version] == 'v1') || (config[:rackspace_version] == 'v1')
+        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_auth_url #{auth_endpoint} (using)")
+        Chef::Log.debug("rackspace_region #{Chef::Config[:knife][:rackspace_region]}")
+        Chef::Log.debug("rackspace_region #{config[:rackspace_region]}")
+        
+        if version_one?
           Chef::Log.debug("rackspace v1")
+          region_warning_for_v1
           @connection ||= begin
             connection = Fog::Compute.new(connection_params({
               :version => 'v1'
@@ -96,19 +99,25 @@ class Chef
           Chef::Log.debug("rackspace v2")
           @connection ||= begin
             connection = Fog::Compute.new(connection_params({
-              :version => 'v2',
-              :rackspace_endpoint => Chef::Config[:knife][:rackspace_endpoint] || config[:rackspace_endpoint]
+              :version => 'v2'
             }))
           end
         end
       end
+      
+      def region_warning_for_v1
+        if Chef::Config[:knife][:rackspace_region] || config[:rackspace_region]
+          Chef::Log.warn("Ignoring the rackspace_region parameter as it is only supported for Next Gen Cloud Servers (v2)")
+        end
+      end
 
       def connection_params(options={})
         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_auth_url => Chef::Config[:knife][:rackspace_auth_url] || config[:rackspace_auth_url]
+          :rackspace_auth_url => auth_endpoint,
+          :rackspace_region => locate_config_value(:rackspace_region)
         })
 
         hash[:connection_options] ||= {}
@@ -124,6 +133,12 @@ class Chef
         hash
       end
 
+      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
+
       def locate_config_value(key)
         key = key.to_sym
         Chef::Config[:knife][key] || config[key]
@@ -168,7 +183,7 @@ class Chef
       end
 
       def rackspace_api_version
-        version = Chef::Config[:knife][:rackspace_version] || 'v2'
+        version = locate_config_value(:rackspace_version) || 'v2'
         version.downcase
       end
 

data/lib/chef/knife/rackspace_server_create.rb

@@ -27,7 +27,7 @@ class Chef
 
       include Knife::RackspaceBase
       include Chef::Knife::WinrmBase
-      
+
 
       deps do
         require 'fog'
@@ -81,6 +81,13 @@ class Chef
         :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 }
+
       option :identity_file,
         :short => "-i IDENTITY_FILE",
         :long => "--identity-file IDENTITY_FILE",
@@ -157,23 +164,29 @@ class Chef
           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 600 seconds",
-      :default => 600,
-      :proc => Proc.new { |v| Chef::Config[:knife][:server_create_timeouts] = v}
+        :long => "--server-create-timeout timeout",
+        :description => "How long to wait until the server is ready; default is 600 seconds",
+        :default => 600,
+        :proc => Proc.new { |v| Chef::Config[:knife][:server_create_timeouts] = 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), default is AUTO",
+        :proc => Proc.new { |k| Chef::Config[:knife][:rackspace_disk_config] = k },
+        :default => "AUTO"
+
 
       def load_winrm_deps
         require 'winrm'
@@ -182,9 +195,10 @@ class Chef
         require 'chef/knife/core/windows_bootstrap_context'
         require 'chef/knife/winrm'
       end
-      
+
       def tcp_test_ssh(hostname)
-        tcp_socket = TCPSocket.new(hostname, 22)
+        ssh_port = Chef::Config[:knife][:ssh_port] || config[:ssh_port]
+        tcp_socket = TCPSocket.new(hostname, ssh_port)
         readable = IO.select([tcp_socket], nil, nil, 5)
         if readable
           Chef::Log.debug("sshd accepting connections on #{hostname}, banner is #{tcp_socket.gets}")
@@ -216,7 +230,7 @@ class Chef
         end
         [dest, src]
       end
-      
+
       def encode_file(file)
         begin
           filename = File.expand_path(file)
@@ -227,7 +241,7 @@ class Chef
         end
         Base64.encode64(content)
       end
-      
+
       def files
         return {} unless  Chef::Config[:knife][:file]
 
@@ -235,7 +249,7 @@ class Chef
         Chef::Config[:knife][:file].each do |arg|
           dest, src = parse_file_argument(arg)
           Chef::Log.debug("Inject file #{src} into #{dest}")
-          files << { 
+          files << {
             :path => dest,
             :contents => encode_file(src)
           }
@@ -244,7 +258,7 @@ class Chef
     end
 
 
-      
+
       def tcp_test_winrm(hostname, port)
         TCPSocket.new(hostname, port)
         return true
@@ -265,7 +279,7 @@ class Chef
         sleep 2
         false
       end
-      
+
 
       def run
         $stdout.sync = true
@@ -274,11 +288,11 @@ class Chef
           ui.error("You have not provided a valid image value.  Please note the short option for this value recently changed from '-i' to '-I'.")
           exit 1
         end
-        
+
         if locate_config_value(:bootstrap_protocol) == 'winrm'
           load_winrm_deps
         end
-        
+
         node_name = get_node_name(config[:chef_node_name] || config[:server_name])
         networks = get_networks(Chef::Config[:knife][:rackspace_networks])
 
@@ -287,11 +301,15 @@ class Chef
           :image_id => Chef::Config[:knife][:image],
           :flavor_id => locate_config_value(:flavor),
           :metadata => Chef::Config[:knife][:rackspace_metadata],
+          :disk_config => Chef::Config[:knife][:rackspace_disk_config],
           :personality => files
         )
-        server.save(
-          :networks => networks
-        )
+
+        if version_one?
+          server.save
+        else
+          server.save(:networks => networks)
+        end
 
         msg_pair("Instance ID", server.id)
         msg_pair("Host ID", server.host_id)
@@ -304,7 +322,7 @@ class Chef
         end
 
         print "\n#{ui.color("Waiting server", :magenta)}"
-        
+
         server.wait_for(Integer(locate_config_value(:server_create_timeout))) { print "."; ready? }
         # wait for it to be ready to do stuff
 
@@ -358,13 +376,14 @@ class Chef
         bootstrap.name_args = [bootstrap_ip_address]
         bootstrap.config[:ssh_user] = config[:ssh_user] || "root"
         bootstrap.config[:ssh_password] = server.password
+        bootstrap.config[:ssh_port] = Chef::Config[:knife][:ssh_port] || config[:ssh_port]
         bootstrap.config[:identity_file] = config[:identity_file]
         bootstrap.config[:host_key_verify] = config[:host_key_verify]
         # 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_common_params(bootstrap, server)
       end
-      
+
       def bootstrap_common_params(bootstrap, server)
         bootstrap.config[:environment] = config[:environment]
         bootstrap.config[:run_list] = config[:run_list]
@@ -380,12 +399,12 @@ class Chef
         bootstrap.config[:first_boot_attributes] = config[: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]  
+        bootstrap.config[:encrypted_data_bag_secret_file] = config[:encrypted_data_bag_secret_file]
         Chef::Config[:knife][:hints] ||= {}
         Chef::Config[:knife][:hints]["rackspace"] ||= {}
         bootstrap
       end
-      
+
       def bootstrap_for_windows_node(server, bootstrap_ip_address)
         bootstrap = Chef::Knife::BootstrapWindowsWinrm.new
         bootstrap.name_args = [bootstrap_ip_address]
@@ -416,7 +435,7 @@ class Chef
           nets = []
         end
         available_networks = connection.networks.all
-        
+
         names.each do |name|
           net = available_networks.detect{|n| n.label == name || n.id == name}
           if(net)

data/lib/knife-rackspace/version.rb

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