knife-rackspace 0.6.2 → 0.7.0

data/.chef/knife.rb

@@ -0,0 +1,18 @@
+current_dir = File.dirname(__FILE__)
+log_level                :info
+log_location             STDOUT
+#node_name                "knife-rackspace"
+#client_key               "#{current_dir}/knife-rackspace.pem"
+#validation_client_name   "knife-rackspace-validator"
+#validation_key           "#{current_dir}/knife-rackspace-validator.pem"
+#chef_server_url          "https://api.opscode.com/organizations/knife-rackspace"
+#cache_type               'basicfile'
+#cache_options( :path => "#{ENV['home']}/.chef/checksums" )
+#cookbook_path            ["#{current_dir}/../cookbooks"]
+
+knife[:rackspace_api_username] = "#{ENV['OS_USERNAME']}"
+knife[:rackspace_api_key] = "#{ENV['OS_PASSWORD']}"
+
+#https_proxy 'https://localhost:8888'
+#knife[:ssl_verify_peer] = false
+

data/.gitignore

@@ -14,6 +14,8 @@ spec/reports
 .config
 InstalledFiles
 .bundle
+.rackspace_cloud_credentials*
+*.lock
 
 # YARD artifacts
 .yardoc

data/.travis.yml

@@ -0,0 +1,28 @@
+---
+language: ruby
+rvm:
+- 2.0.0
+- 1.9.3
+- 1.8.7
+env:
+  global:
+  - secure: ! 'eEsikE/p2yz7/cFvCN/NOoljxBqjzsTWnKC7iZ+fEGGsyhKVJgWn4AasBusZ
+
+      mhtQcOqwakRulzVc+EZN4pqWHgaMC7SnSwhqRU5u1E+BPI4iWNsu+7rjiXhE
+
+      cJK1vE8YodgsgRDQ6evZVQLkwJpRk0qq2tM2LDqpzvy2MeQJIGc='
+  - secure: ! 'V3ohIIF3I8lD05zTUs2nu+CcIzBYcvt1c1euRJ+SPcAH493b4cPquw1NZNFy
+
+      WDIW+1qDQi1DXr8C3Yq8bL4+pY66SukHtxyLhx0V26lGUvI8naq3IqageBQK
+
+      pkb2zZwVYO0a5mLEKOI/7omExBVHDxxX9Bw45vCHLKId3Wt21HE='
+  - secure: ! 'OyKQU1muVBijz2/EkLUgBWbwPKG2UqRhIfpB1ZFkfdQ/06+Vaf82ZEQk3DvY
+
+      2lYFrzvSN1yWrKTMU3XES/dPlVlH87LDOrRhNhgW/NeHhC5BzdwrtvBm08RN
+
+      64ACuFG8fch9zIbx2VTkyLV8xsFXPPSaKMbEXrnikLwqnl5M8PQ='
+  - secure: ! 'DoDVG0HwFg2a7Fj72tlxb8KJto+cBEh7J9YQZ35hK2cmeTsBAcZ4oSOUeAFg
+
+      s2MvBhX0man0zjYPStbL1vcpuS1Ecea3kGzefG0lYhHAzvK7wqqRqhKNFsnd
+
+      FPEVgZrcj3/Lc7mlkbigZouDM7BJLQbMGOv/KOS6f3nYzIhkOfE='

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 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.
+* KNIFE-182 default to Rackspace Open Cloud (v2)
+* KNIFE-267 Rackspace server create with networks
+* KNIFE-271 Enable winrm authentication on knife-rackspace
+* KNIFE-281 pass https_proxy and http_proxy setting onto fog; added ssl_verify_peer setting to disable certificate validation
+* KNIFE-282 Add the ability to inject files on server creation
+* KNIFE-289 Add Integration Tests
+
+* KNOWN ISSUES: KNIFE-296 knife-windows overrides -x option with winrm-user
+
 ## v0.6.2
 * bump release to fix permission issues inside the gem
 

data/Gemfile

@@ -1,4 +1,8 @@
 source "http://rubygems.org"
 
+group :development, :test do
+  gem "knife-dsl", :git => 'git://github.com/maxlinc/knife-dsl.git', :branch => 'io_capture_fix'
+end
+
 # Specify your gem's dependencies in knife-rackspace.gemspec
 gemspec

data/README.rdoc

@@ -33,13 +33,13 @@ You also have the option of passing your Rackspace API Username/Key into the ind
     # provision a new 1GB Ubuntu 10.04 webserver
     knife rackspace server create -I 112 -f 3 -A 'Your Rackspace API username' -K "Your Rackspace API Key" -r 'role[webserver]'
 
-To select for the new OpenStack-based "Rackspace Open Cloud" API (aka 'v2'), you can use the <tt>--rackspace-version v2</tt> command option. 'v1' is still the default, so if you're using exclusively 'v2' you will probably want to add the following to your <tt>knife.rb</tt>:
+To select for the previous Rackspace API (aka 'v1'), you can use the <tt>--rackspace-version v1</tt> command option. 'v2' is the default, so if you're still using exclusively 'v1' you will probably want to add the following to your <tt>knife.rb</tt>:
 
-    knife[:rackspace_version] = 'v2'
+    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>:
 
-    knife[:rackspace_api_auth_url] = "lon.auth.api.rackspacecloud.com"
+    knife[:rackspace_auth_url] = "lon.auth.api.rackspacecloud.com"
 
 This plugin also has support for specifying which region to create servers into:
 
@@ -50,6 +50,14 @@ valid options include:
       ORD_ENDPOINT = 'https://ord.servers.api.rackspacecloud.com/v2'
       LON_ENDPOINT = 'https://lon.servers.api.rackspacecloud.com/v2'
 
+If you are behind a proxy you can specify it in the knife.rb file as follows:
+
+	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
+
 Additionally the following options may be set in your `knife.rb`:
 
 * flavor
@@ -67,6 +75,12 @@ Provisions a new server in the Rackspace Cloud and then perform a Chef bootstrap
 
 If no name is provided, nodes created with  the v1 API are named after their instance ID, with the v2 API they are given a random 'rs-XXXXXXXXX' name.
 
+Files can be injected onto the provisioned system using the <tt>--file</tt> switch. For example to inject <tt>my_script.sh</tt> into <tt>/root/initialize.sh</tt> you would use the following switch
+
+    --file /root/initialize.sh=my_script.sh.
+
+Note: You can only inject text files and the maximum destination path is 255 characters.
+
 == 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.

data/Rakefile

@@ -19,3 +19,33 @@
 
 require 'bundler'
 Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => [:credentials, :spec, 'integration:live']
+
+task :credentials do
+  if ENV['TRAVIS_SECURE_ENV_VARS'] == 'false'
+    puts "Setting vars"
+    ENV['OS_USERNAME'] = '_RAX_USERNAME_'
+    ENV['OS_PASSWORD'] = '_RAX_PASSWORD_'
+    ENV['RS_TENANT_ID'] = '000000'
+    ENV['RS_CDN_TENANT_NAME'] = '_CDN-TENANT-NAME_'
+  end
+  fail "Not all required variables detected" unless ENV['OS_USERNAME'] && ENV['OS_PASSWORD'] && ENV['RS_CDN_TENANT_NAME'] && ENV['RS_TENANT_ID']
+end
+
+namespace :integration do
+  desc 'Run the integration tests'
+  RSpec::Core::RakeTask.new(:test) do |t|
+    t.pattern = 'spec/integration/**'
+  end
+
+  desc 'Run the integration tests live (no VCR cassettes)'
+  task :live do
+    unless ENV['TRAVIS'] == 'true' && ENV['TRAVIS_SECURE_ENV_VARS'] == 'false'
+      ENV['INTEGRATION_TESTS'] = 'live'
+      Rake::Task['integration:test'].invoke
+    end
+  end
+end

data/knife-rackspace.gemspec

@@ -17,7 +17,14 @@ 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 "fog", "~> 1.6"
+  s.add_dependency "knife-windows"
   s.add_dependency "chef", ">= 0.10.10"
   s.require_paths = ["lib"]
 
+  # In Gemfile because I'm using a fork on Github.  Hopefully pull request will be merged and a new gem will be released soon.
+  # s.add_development_dependency "knife-dsl"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "vcr"
+  s.add_development_dependency "ansi"
+  s.add_development_dependency "rake"
 end

data/lib/chef/knife/rackspace_base.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Seth Chisamore (<schisamo@opscode.com>)
-# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# Copyright:: Copyright (c) 2011-2013 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -50,57 +50,80 @@ class Chef
           option :rackspace_version,
             :long => '--rackspace-version VERSION',
             :description => 'Rackspace Cloud Servers API version',
-            :default => "v1",
+            :default => "v2",
             :proc => Proc.new { |version| Chef::Config[:knife][:rackspace_version] = version }
 
-          option :rackspace_api_auth_url,
-            :long => "--rackspace-api-auth-url URL",
+          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_api_auth_url] = url }
+            :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 :file,
+            :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
+            }
         end
       end
 
       def connection
-        Chef::Log.debug("version #{Chef::Config[:knife][:rackspace_version]}") #config file
-        Chef::Log.debug("version #{config[:rackspace_version]}") #cli
+        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_endpoint #{Chef::Config[:knife][:rackspace_endpoint]}")
-        Chef::Log.debug("rackspace_endpoint #{config[:rackspace_endpoint]}")
-        if (Chef::Config[:knife][:rackspace_version] == 'v2') || (config[:rackspace_version] == 'v2')
+        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 v1")
           @connection ||= begin
-            connection = Fog::Compute.new(
-              :provider => 'Rackspace',
-              :version => 'v2',
-              :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_api_auth_url] || config[:rackspace_api_auth_url],
-              :rackspace_endpoint => Chef::Config[:knife][:rackspace_endpoint] || config[:rackspace_endpoint]
-            )
+            connection = Fog::Compute.new(connection_params({
+              :version => 'v1'
+              }))
           end
         else
+          Chef::Log.debug("rackspace v2")
           @connection ||= begin
-            connection = Fog::Compute.new(
-              :provider => 'Rackspace',
-              :version => 'v1',
-              :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_api_auth_url] || config[:rackspace_api_auth_url]
-            )
+            connection = Fog::Compute.new(connection_params({
+              :version => 'v2',
+              :rackspace_endpoint => Chef::Config[:knife][:rackspace_endpoint] || config[:rackspace_endpoint]
+            }))
           end
         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]
+        })
+
+        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] }
+        end
+        Chef::Log.debug("using proxy #{hash[:connection_options][:proxy] || "<none>"} (config)")
+        Chef::Log.debug("ssl_verify_peer #{Chef::Config[:knife].include?(: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].include?(:ssl_verify_peer)
+
+        hash
+      end
+
       def locate_config_value(key)
         key = key.to_sym
         Chef::Config[:knife][key] || config[key]
@@ -134,7 +157,7 @@ class Chef
         @public_dns_name ||= begin
           Resolv.getname(ip_address)
         rescue
-          "#{ip_address.gsub('.','-')}.static.cloud-ips.com"
+          "#{ip_address.gsub('.','-')}.static.cloud-ips.com" if ip_address
         end
       end
 
@@ -145,7 +168,7 @@ class Chef
       end
 
       def rackspace_api_version
-        version = Chef::Config[:knife][:rackspace_version] || 'v1'
+        version = Chef::Config[:knife][:rackspace_version] || 'v2'
         version.downcase
       end
 

data/lib/chef/knife/rackspace_network_create.rb

@@ -0,0 +1,46 @@
+require 'chef/knife/rackspace_base'
+
+class Chef
+  class Knife
+    class RackspaceNetworkCreate < Knife
+
+      include Knife::RackspaceBase
+
+      banner "knife rackspace network create (options)"
+      
+      option :label,
+        :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
+      
+      def run
+        if version_one?
+          ui.error "Networks are not supported in v1"
+          exit 1
+        else
+          networks_list = [
+            ui.color('Label', :bold),
+            ui.color('CIDR', :bold),
+            ui.color('ID', :bold)
+          ]
+        end
+        options = {}
+        [:cidr, :label].each do |key|
+          options[key] = config[key]
+        end
+        net = connection.networks.create(options)
+
+        msg_pair("Network ID", net.id)
+        msg_pair("Label", net.label)
+        msg_pair("CIDR", net.cidr)
+      end
+    end
+  end
+end

data/lib/chef/knife/rackspace_network_delete.rb

@@ -0,0 +1,37 @@
+require 'chef/knife/rackspace_base'
+
+class Chef
+  class Knife
+    class RackspaceNetworkDelete < Knife
+
+      include Knife::RackspaceBase
+
+      banner "knife rackspace network delete NETWORK_ID [NETWORK_ID] (options)"
+      
+      def run
+        if version_one?
+          ui.error "Networks are not supported in v1"
+          exit 1
+        else
+          @name_args.each do |net_id|
+            network = connection.networks.get(net_id)
+            unless(network)
+              ui.error "Could not locate network: #{net_id}"
+              exit 1
+            end
+            msg_pair("Network ID", network.id)
+            msg_pair("Label", network.label)
+            msg_pair("CIDR", network.cidr)
+            
+            puts "\n"
+            confirm("Do you really want to delete this network")
+
+            network.destroy
+
+            ui.warn("Deleted network #{network.id}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/rackspace_network_list.rb

@@ -0,0 +1,31 @@
+require 'chef/knife/rackspace_base'
+
+class Chef
+  class Knife
+    class RackspaceNetworkList < Knife
+
+      include Knife::RackspaceBase
+
+      banner "knife rackspace network list (options)"
+
+      def run
+        if version_one?
+          ui.error "Networks are not supported in v1"
+          exit 1
+        else
+          networks_list = [
+            ui.color('Label', :bold),
+            ui.color('CIDR', :bold),
+            ui.color('ID', :bold)
+          ]
+        end
+        connection.networks.sort_by(&:id).each do |network|
+          networks_list << network.label
+          networks_list << network.cidr
+          networks_list << network.id.to_s
+        end
+        puts ui.list(networks_list, :uneven_columns_across, 3)
+      end
+    end
+  end
+end

data/lib/chef/knife/rackspace_server_create.rb

@@ -18,12 +18,16 @@
 #
 
 require 'chef/knife/rackspace_base'
+require 'chef/knife/winrm_base'
+require 'chef/knife'
 
 class Chef
   class Knife
     class RackspaceServerCreate < Knife
 
       include Knife::RackspaceBase
+      include Chef::Knife::WinrmBase
+      
 
       deps do
         require 'fog'
@@ -35,6 +39,8 @@ class Chef
 
       banner "knife rackspace server create (options)"
 
+      attr_accessor :initial_sleep_delay
+
       option :flavor,
         :short => "-f FLAVOR",
         :long => "--flavor FLAVOR",
@@ -123,12 +129,60 @@ class Chef
         :proc => Proc.new { |m| Chef::Config[:knife][:rackspace_metadata] = JSON.parse(m) },
         :default => ""
 
+      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|
+           Chef::Config[:knife][:hints] ||= {}
+           name, path = h.split("=")
+           Chef::Config[:knife][:hints][name] = path ? JSON.parse(::File.read(path)) : Hash.new
+        }
+
       option :host_key_verify,
         :long => "--[no-]host-key-verify",
         :description => "Verify host key, enabled by default",
         :boolean => true,
         :default => true
 
+      option :default_networks,
+        :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|
+          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
+
+      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}
+
+      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 }
+     
+
+      def load_winrm_deps
+        require 'winrm'
+        require 'em-winrm'
+        require 'chef/knife/bootstrap_windows_winrm'
+        require 'chef/knife/core/windows_bootstrap_context'
+        require 'chef/knife/winrm'
+      end
+      
       def tcp_test_ssh(hostname)
         tcp_socket = TCPSocket.new(hostname, 22)
         readable = IO.select([tcp_socket], nil, nil, 5)
@@ -153,6 +207,66 @@ class Chef
         tcp_socket && tcp_socket.close
       end
 
+
+      def parse_file_argument(arg)
+        dest, src = arg.split('=')
+        unless dest && src
+          ui.error "Unable to process file arguments #{arg}. The --file option requires both the destination on the remote machine as well as the local source be supplied using the form DESTINATION-PATH=SOURCE-PATH"
+          exit 1
+        end
+        [dest, src]
+      end
+      
+      def encode_file(file)
+        begin
+          filename = File.expand_path(file)
+          content = File.read(filename)
+        rescue Errno::ENOENT => e
+          ui.error "Unable to read source file - #{filename}"
+          exit 1
+        end
+        Base64.encode64(content)
+      end
+      
+      def files
+        return {} unless  Chef::Config[:knife][:file]
+
+        files = []
+        Chef::Config[:knife][:file].each do |arg|
+          dest, src = parse_file_argument(arg)
+          Chef::Log.debug("Inject file #{src} into #{dest}")
+          files << { 
+            :path => dest,
+            :contents => encode_file(src)
+          }
+      end
+      files
+    end
+
+
+      
+      def tcp_test_winrm(hostname, port)
+        TCPSocket.new(hostname, port)
+        return true
+      rescue SocketError
+        sleep 2
+        false
+      rescue Errno::ETIMEDOUT
+        false
+      rescue Errno::EPERM
+        false
+      rescue Errno::ECONNREFUSED
+        sleep 2
+        false
+      rescue Errno::EHOSTUNREACH
+        sleep 2
+        false
+      rescue Errno::ENETUNREACH
+        sleep 2
+        false
+      end
+      
+
       def run
         $stdout.sync = true
 
@@ -160,15 +274,24 @@ 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])
 
-        server = connection.servers.create(
+        server = connection.servers.new(
           :name => node_name,
           :image_id => Chef::Config[:knife][:image],
           :flavor_id => locate_config_value(:flavor),
-          :metadata => Chef::Config[:knife][:rackspace_metadata]
-          )
+          :metadata => Chef::Config[:knife][:rackspace_metadata],
+          :personality => files
+        )
+        server.save(
+          :networks => networks
+        )
 
         msg_pair("Instance ID", server.id)
         msg_pair("Host ID", server.host_id)
@@ -176,11 +299,14 @@ class Chef
         msg_pair("Flavor", server.flavor.name)
         msg_pair("Image", server.image.name)
         msg_pair("Metadata", server.metadata)
+        if(networks && Chef::Config[:knife][:rackspace_networks])
+          msg_pair("Networks", Chef::Config[:knife][:rackspace_networks].sort.join(', '))
+        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
-        server.wait_for { print "."; ready? }
 
         puts("\n")
 
@@ -188,9 +314,6 @@ class Chef
         msg_pair("Public IP Address", public_ip(server))
         msg_pair("Private IP Address", private_ip(server))
         msg_pair("Password", server.password)
-
-        print "\n#{ui.color("Waiting for sshd", :magenta)}"
-
         #which IP address to bootstrap
         bootstrap_ip_address = public_ip(server)
         if config[:private_network]
@@ -202,11 +325,18 @@ class Chef
           exit 1
         end
 
+      if locate_config_value(:bootstrap_protocol) == 'winrm'
+        print "\n#{ui.color("Waiting for winrm", :magenta)}"
+        print(".") until tcp_test_winrm(bootstrap_ip_address, locate_config_value(:winrm_port))
+        bootstrap_for_windows_node(server, bootstrap_ip_address).run
+      else
+        print "\n#{ui.color("Waiting for sshd", :magenta)}"
         print(".") until tcp_test_ssh(bootstrap_ip_address) {
           sleep @initial_sleep_delay ||= 10
           puts("done")
         }
         bootstrap_for_node(server, bootstrap_ip_address).run
+      end
 
         puts "\n"
         msg_pair("Instance ID", server.id)
@@ -226,26 +356,45 @@ class Chef
       def bootstrap_for_node(server, bootstrap_ip_address)
         bootstrap = Chef::Knife::Bootstrap.new
         bootstrap.name_args = [bootstrap_ip_address]
-        bootstrap.config[:run_list] = config[:run_list]
-        bootstrap.config[:first_boot_attributes] = config[:first_boot_attributes]
         bootstrap.config[:ssh_user] = config[:ssh_user] || "root"
         bootstrap.config[:ssh_password] = server.password
         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]
         if version_one?
           bootstrap.config[:chef_node_name] = config[:chef_node_name] || server.id
         else
-          bootstrap.config[:chef_node_name] = server.name
+          bootstrap.config[:chef_node_name] = config[:chef_node_name] || server.name
         end
         bootstrap.config[:prerelease] = config[:prerelease]
         bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
         bootstrap.config[:distro] = locate_config_value(:distro)
-        # 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[:template_file] = locate_config_value(:template_file)
-        bootstrap.config[:environment] = config[:environment]
+        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]  
+        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]
+        bootstrap.config[:winrm_user] = locate_config_value(:winrm_user) || 'Administrator'
+        bootstrap.config[:winrm_password] = locate_config_value(:winrm_password) || server.password
+        bootstrap.config[:winrm_transport] = locate_config_value(:winrm_transport)
+        bootstrap.config[:winrm_port] = locate_config_value(:winrm_port)
+        bootstrap_common_params(bootstrap, server)
+      end
 
     end
     #v2 servers require a name, random if chef_node_name is empty, empty if v1
@@ -254,5 +403,34 @@ class Chef
       #lazy uuids
       chef_node_name = "rs-"+rand.to_s.split('.')[1] unless version_one?
     end
+
+    def get_networks(names)
+      names = Array(names)
+      if(Chef::Config[:knife][:rackspace_version] == 'v2')
+        if(config[:default_networks])
+          nets = [
+            '00000000-0000-0000-0000-000000000000',
+            '11111111-1111-1111-1111-111111111111'
+          ]
+        else
+          nets = []
+        end
+        available_networks = connection.networks.all
+        
+        names.each do |name|
+          net = available_networks.detect{|n| n.label == name || n.id == name}
+          if(net)
+            nets << net.id
+          else
+            ui.error("Failed to locate network: #{name}")
+            exit 1
+          end
+        end
+        nets
+      elsif(names && !names.empty?)
+        ui.error("Custom networks are only available in v2 API")
+        exit 1
+      end
+    end
   end
 end