knife-windows 0.5.3 → 0.5.4

data/CHANGELOG

@@ -0,0 +1,9 @@
+Release Notes - Knife Windows Plugin - Version 0.5.4
+
+** Bug
+    * [KNIFE_WINDOWS-7] - Exception: NoMethodError: undefined method `env_namespace' for Savon:Module
+    * [KNIFE_WINDOWS-8] - winrm based bootstrap fails with 'Bad HTTP response returned from server (500)'
+
+
+** New Feature
+    * [KNIFE_WINDOWS-6] - default bootstrap template should support encrypted_data_bag_secret

data/README.rdoc

@@ -90,6 +90,10 @@ The Chef and Ohai gem installations (that occur during bootstrap) take more memo
 
     C:\Users\Administrator> winrm set winrm/config/winrs @{MaxMemoryPerShellMB="300"}
 
+Bootstrap commands can take longer than the WinRM default 60 seconds to complete, bump to 30 minutes:
+
+    C:\Users\Administrator> winrm set winrm/config @{MaxTimeoutms="1800000"}
+
 WinRM supports both the HTTP and HTTPS transports and the following authentication schemes: Kerberos, Digest, Certificate and Basic.  The details of these authentication transports are outside of the scope of this README but details can be found on the {WinRM configuration guide}[http://msdn.microsoft.com/en-us/library/aa384372(v=vs.85).aspx].  Currently, this plugin support Kerberos and Basic authentication schemes.
 
 For development and testing purposes, unencrypted traffic with Basic authentication can make things easier:

data/knife-windows.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
   s.description = s.summary
 
   s.required_ruby_version	= ">= 1.9.1"
-  s.add_dependency "em-winrm", "= 0.0.5"
+  s.add_dependency "em-winrm", "= 0.5.2"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/chef/knife/bootstrap/windows-shell.erb

@@ -44,6 +44,12 @@ cmd.exe /C C:\ruby\bin\gem install chef --no-rdoc --no-ri --verbose <%= bootstra
  <%= validation_key %>
 )
 
+<% if @config[:encrypted_data_bag_secret] -%>
+> C:\chef\encrypted_data_bag_secret (
+ <%= encrypted_data_bag_secret %>
+)
+<% end -%>
+
 > C:\chef\client.rb (
  echo.require 'win32ole'
  echo.WIN32OLE.codepage = WIN32OLE::CP_UTF8

data/lib/chef/knife/bootstrap_windows_base.rb

@@ -0,0 +1,175 @@
+#
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/knife'
+require 'chef/encrypted_data_bag_item'
+
+class Chef
+  class Knife
+    module BootstrapWindowsBase
+
+      # :nodoc:
+      # Would prefer to do this in a rational way, but can't be done b/c of
+      # Mixlib::CLI's design :(
+      def self.included(includer)
+        includer.class_eval do
+
+          deps do
+            require 'readline'
+            require 'chef/json_compat'
+          end
+
+          option :chef_node_name,
+            :short => "-N NAME",
+            :long => "--node-name NAME",
+            :description => "The Chef node name for your new node"
+
+          option :prerelease,
+            :long => "--prerelease",
+            :description => "Install the pre-release chef gems"
+
+          option :bootstrap_version,
+            :long => "--bootstrap-version VERSION",
+            :description => "The version of Chef to install",
+            :proc => Proc.new { |v| Chef::Config[:knife][:bootstrap_version] = v }
+
+          option :bootstrap_proxy,
+            :long => "--bootstrap-proxy PROXY_URL",
+            :description => "The proxy server for the node being bootstrapped",
+            :proc => Proc.new { |p| Chef::Config[:knife][:bootstrap_proxy] = p }
+
+          option :distro,
+            :short => "-d DISTRO",
+            :long => "--distro DISTRO",
+            :description => "Bootstrap a distro using a template",
+            :default => "windows-shell"
+
+          option :template_file,
+            :long => "--template-file TEMPLATE",
+            :description => "Full path to location of template to use",
+            :default => false
+
+          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(",") },
+            :default => []
+
+          option :encrypted_data_bag_secret,
+            :short => "-s SECRET",
+            :long  => "--secret ",
+            :description => "The secret key to use to decrypt data bag item values.  Will be rendered on the node at c:/chef/encrypted_data_bag_secret and set in the rendered client config.",
+            :default => false
+
+          option :encrypted_data_bag_secret_file,
+            :long => "--secret-file SECRET_FILE",
+            :description => "A file containing the secret key to use to encrypt data bag item values. Will be rendered on the node at c:/chef/encrypted_data_bag_secret and set in the rendered client config."
+
+        end
+      end
+
+      # TODO: This should go away when CHEF-2193 is fixed
+      def load_template(template=nil)
+        # Are we bootstrapping using an already shipped template?
+        if config[:template_file]
+          bootstrap_files = config[:template_file]
+        else
+          bootstrap_files = []
+          bootstrap_files << File.join(File.dirname(__FILE__), 'bootstrap', "#{config[:distro]}.erb")
+          bootstrap_files << File.join(Dir.pwd, ".chef", "bootstrap", "#{config[:distro]}.erb")
+          bootstrap_files << File.join(ENV['HOME'], '.chef', 'bootstrap', "#{config[:distro]}.erb")
+          bootstrap_files << Gem.find_files(File.join("chef","knife","bootstrap","#{config[:distro]}.erb"))
+          bootstrap_files.flatten!
+        end
+
+        template = Array(bootstrap_files).find do |bootstrap_template|
+          Chef::Log.debug("Looking for bootstrap template in #{File.dirname(bootstrap_template)}")
+          ::File.exists?(bootstrap_template)
+        end
+
+        unless template
+          ui.info("Can not find bootstrap definition for #{config[:distro]}")
+          raise Errno::ENOENT
+        end
+
+        Chef::Log.debug("Found bootstrap template in #{File.dirname(template)}")
+
+        IO.read(template).chomp
+      end
+
+      def render_template(template=nil)
+        if config[:encrypted_data_bag_secret_file]
+          config[:encrypted_data_bag_secret] = Chef::EncryptedDataBagItem.load_secret(config[:encrypted_data_bag_secret_file])
+        end
+        context = Knife::Core::WindowsBootstrapContext.new(config, config[:run_list], Chef::Config)
+        Erubis::Eruby.new(template).evaluate(context)
+      end
+
+      def bootstrap(proto=nil)
+
+        validate_name_args!
+
+        @node_name = Array(@name_args).first
+        # back compat--templates may use this setting:
+        config[:server_name] = @node_name
+
+        STDOUT.sync = STDERR.sync = true
+
+        ui.info("Bootstrapping Chef on #{ui.color(@node_name, :bold)}")
+        # create a bootstrap.bat file on the node
+        # we have to run the remote commands in 2047 char chunks
+        create_bootstrap_bat_command do |command_chunk, chunk_num|
+          run_command("cmd.exe /C echo \"Rendering bootstrap.bat chunk #{chunk_num}\" && #{command_chunk}").run
+        end
+
+        # execute the bootstrap.bat file
+        run_command(bootstrap_command).run
+      end
+
+      def bootstrap_command
+        @bootstrap_command ||= "cmd.exe /C #{bootstrap_bat_file}"
+      end
+
+      def create_bootstrap_bat_command(&block)
+        bootstrap_bat = []
+        chunk_num = 0
+        render_template(load_template(config[:bootstrap_template])).each_line do |line|
+          # escape WIN BATCH special chars
+          line.gsub!(/[(<|>)^]/).each{|m| "^#{m}"}
+          # windows commands are limited to 2047 characters
+          if((bootstrap_bat + [line]).join(" && ").size > 2047 )
+            yield bootstrap_bat.join(" && "), chunk_num += 1
+            bootstrap_bat = []
+          end
+          bootstrap_bat << ">> #{bootstrap_bat_file} (echo.#{line.chomp.strip})"
+        end
+        yield bootstrap_bat.join(" && "), chunk_num += 1
+      end
+
+      def bootstrap_bat_file
+        "%TEMP%\\bootstrap.bat"
+      end
+
+      def locate_config_value(key)
+        key = key.to_sym
+        Chef::Config[:knife][key] || config[key]
+      end
+    end
+  end
+end

data/lib/chef/knife/bootstrap_windows_ssh.rb

@@ -16,13 +16,13 @@
 # limitations under the License.
 #
 
-require File.join(File.dirname(__FILE__), 'mixin/windows/bootstrap')
+require 'chef/knife/bootstrap_windows_base'
 
 class Chef
   class Knife
     class BootstrapWindowsSsh < Bootstrap
 
-      include Chef::Mixin::Bootstrap
+      include Chef::Knife::BootstrapWindowsBase
 
       deps do
         require 'chef/knife/core/windows_bootstrap_context'
@@ -59,43 +59,6 @@ class Chef
         :long => "--identity-file IDENTITY_FILE",
         :description => "The SSH identity file used for authentication"
 
-      option :chef_node_name,
-        :short => "-N NAME",
-        :long => "--node-name NAME",
-        :description => "The Chef node name for your new node"
-
-      option :prerelease,
-        :long => "--prerelease",
-        :description => "Install the pre-release chef gems"
-
-      option :bootstrap_version,
-        :long => "--bootstrap-version VERSION",
-        :description => "The version of Chef to install",
-        :proc => Proc.new { |v| Chef::Config[:knife][:bootstrap_version] = v }
-
-      option :bootstrap_proxy,
-        :long => "--bootstrap-proxy PROXY_URL",
-        :description => "The proxy server for the node being bootstrapped",
-        :proc => Proc.new { |p| Chef::Config[:knife][:bootstrap_proxy] = p }
-
-      option :distro,
-        :short => "-d DISTRO",
-        :long => "--distro DISTRO",
-        :description => "Bootstrap a distro using a template",
-        :default => "windows-shell"
-
-      option :template_file,
-        :long => "--template-file TEMPLATE",
-        :description => "Full path to location of template to use",
-        :default => false
-
-      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(",") },
-        :default => []
-
       option :no_host_key_verify,
         :long => "--no-host-key-verify",
         :description => "Disable host key verification",

data/lib/chef/knife/bootstrap_windows_winrm.rb

@@ -16,13 +16,15 @@
 # limitations under the License.
 #
 
-require File.join(File.dirname(__FILE__), 'mixin/windows/bootstrap')
+require 'chef/knife/bootstrap_windows_base'
+require 'chef/knife/winrm_base'
 
 class Chef
   class Knife
     class BootstrapWindowsWinrm < Bootstrap
 
-      include Chef::Mixin::Bootstrap
+      include Chef::Knife::BootstrapWindowsBase
+      include Chef::Knife::WinrmBase
 
       deps do
         require 'chef/knife/core/windows_bootstrap_context'
@@ -33,99 +35,6 @@ class Chef
 
       banner "knife bootstrap windows winrm FQDN (options)"
 
-      option :winrm_user,
-        :short => "-x USERNAME",
-        :long => "--winrm-user USERNAME",
-        :description => "The WinRM username",
-        :default => "Administrator",
-        :proc => Proc.new { |key| Chef::Config[:knife][:winrm_user] = key }
-
-      option :winrm_password,
-        :short => "-P PASSWORD",
-        :long => "--winrm-password PASSWORD",
-        :description => "The WinRM password",
-        :proc => Proc.new { |key| Chef::Config[:knife][:winrm_password] = key }
-
-      option :winrm_port,
-        :short => "-p PORT",
-        :long => "--winrm-port PORT",
-        :description => "The WinRM port, by default this is 5985",
-        :default => "5985",
-        :proc => Proc.new { |key| Chef::Config[:knife][:winrm_port] = key }
-
-      option :identity_file,
-        :short => "-i IDENTITY_FILE",
-        :long => "--identity-file IDENTITY_FILE",
-        :description => "The SSH identity file used for authentication"
-
-      option :winrm_transport,
-        :short => "-t TRANSPORT",
-        :long => "--winrm-transport TRANSPORT",
-        :description => "The WinRM transport type.  valid choices are [ssl, plaintext]",
-        :default => 'plaintext',
-        :proc => Proc.new { |transport| Chef::Config[:knife][:winrm_transport] = transport }
-
-      option :keytab_file,
-        :short => "-i KEYTAB_FILE",
-        :long => "--keytab-file KEYTAB_FILE",
-        :description => "The Kerberos keytab file used for authentication",
-        :proc => Proc.new { |keytab| Chef::Config[:knife][:keytab_file] = keytab }
-
-      option :kerberos_realm,
-        :short => "-R KERBEROS_REALM",
-        :long => "--kerberos-realm KERBEROS_REALM",
-        :description => "The Kerberos realm used for authentication",
-        :proc => Proc.new { |realm| Chef::Config[:knife][:kerberos_realm] = realm }
-
-      option :kerberos_service,
-        :short => "-S KERBEROS_SERVICE",
-        :long => "--kerberos-service KERBEROS_SERVICE",
-        :description => "The Kerberos service used for authentication",
-        :proc => Proc.new { |service| Chef::Config[:knife][:kerberos_service] = service }
-
-      option :ca_trust_file,
-        :short => "-f CA_TRUST_FILE",
-        :long => "--ca-trust-file CA_TRUST_FILE",
-        :description => "The Certificate Authority (CA) trust file used for SSL transport",
-        :proc => Proc.new { |trust| Chef::Config[:knife][:ca_trust_file] = trust }
-
-      option :chef_node_name,
-        :short => "-N NAME",
-        :long => "--node-name NAME",
-        :description => "The Chef node name for your new node"
-
-      option :prerelease,
-        :long => "--prerelease",
-        :description => "Install the pre-release chef gems"
-
-      option :bootstrap_version,
-        :long => "--bootstrap-version VERSION",
-        :description => "The version of Chef to install",
-        :proc => Proc.new { |v| Chef::Config[:knife][:bootstrap_version] = v }
-
-      option :bootstrap_proxy,
-        :long => "--bootstrap-proxy PROXY_URL",
-        :description => "The proxy server for the node being bootstrapped",
-        :proc => Proc.new { |p| Chef::Config[:knife][:bootstrap_proxy] = p }
-
-      option :distro,
-        :short => "-d DISTRO",
-        :long => "--distro DISTRO",
-        :description => "Bootstrap a distro using a template",
-        :default => "windows-shell"
-
-      option :template_file,
-        :long => "--template-file TEMPLATE",
-        :description => "Full path to location of template to use",
-        :default => false
-
-      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(",") },
-        :default => []
-
       def run
         bootstrap
       end

data/lib/chef/knife/core/windows_bootstrap_context.rb

@@ -40,6 +40,10 @@ class Chef
           escape_and_echo(super)
         end
 
+        def encrypted_data_bag_secret
+          escape_and_echo(@config[:encrypted_data_bag_secret])
+        end
+
         def config_content
           client_rb = <<-CONFIG
 log_level        :info
@@ -60,13 +64,17 @@ CONFIG
           else
             client_rb << "# Using default node name (fqdn)\n"
           end
-          
+
           if knife_config[:bootstrap_proxy]
             client_rb << "\n"
             client_rb << %Q{http_proxy        "#{knife_config[:bootstrap_proxy]}"\n}
             client_rb << %Q{https_proxy       "#{knife_config[:bootstrap_proxy]}"\n}
           end
-          
+
+          if @config[:encrypted_data_bag_secret]
+            client_rb << %Q{encrypted_data_bag_secret "c:/chef/encrypted_data_bag_secret"\n}
+          end
+
           escape_and_echo(client_rb)
         end
 

data/lib/chef/knife/winrm.rb

@@ -17,14 +17,18 @@
 #
 
 require 'chef/knife'
+require 'chef/knife/winrm_base'
 
 class Chef
   class Knife
     class Winrm < Knife
 
+      include Chef::Knife::WinrmBase
+
       deps do
         require 'readline'
         require 'chef/search/query'
+        require 'em-winrm'
       end
 
       attr_writer :password
@@ -44,65 +48,7 @@ class Chef
         :description => "QUERY is a space separated list of servers",
         :default => false
 
-      option :winrm_user,
-        :short => "-x USERNAME",
-        :long => "--winrm-user USERNAME",
-        :description => "The WinRM username",
-        :default => "Administrator",
-        :proc => Proc.new { |key| Chef::Config[:knife][:winrm_user] = key }
-
-      option :winrm_password,
-        :short => "-P PASSWORD",
-        :long => "--winrm-password PASSWORD",
-        :description => "The WinRM password",
-        :proc => Proc.new { |key| Chef::Config[:knife][:winrm_password] = key }
-
-      option :winrm_port,
-        :short => "-p PORT",
-        :long => "--winrm-port PORT",
-        :description => "The WinRM port",
-        :default => "5985",
-        :proc => Proc.new { |key| Chef::Config[:knife][:winrm_port] = key }
-
-      option :winrm_transport,
-        :short => "-t TRANSPORT",
-        :long => "--winrm-transport TRANSPORT",
-        :description => "The WinRM transport type: ssl, or plaintext",
-        :default => 'plaintext',
-        :proc => Proc.new { |transport| Chef::Config[:knife][:winrm_transport] = transport }
-
-      option :kerberos_keytab_file,
-        :short => "-i KEYTAB_FILE",
-        :long => "--keytab-file KEYTAB_FILE",
-        :description => "The Kerberos keytab file used for authentication",
-        :proc => Proc.new { |keytab| Chef::Config[:knife][:kerberos_keytab_file] = keytab }
-
-      option :kerberos_realm,
-        :short => "-R KERBEROS_REALM",
-        :long => "--kerberos-realm KERBEROS_REALM",
-        :description => "The Kerberos realm used for authentication",
-        :proc => Proc.new { |realm| Chef::Config[:knife][:kerberos_realm] = realm }
-
-      option :kerberos_service,
-        :short => "-S KERBEROS_SERVICE",
-        :long => "--kerberos-service KERBEROS_SERVICE",
-        :description => "The Kerberos service used for authentication",
-        :proc => Proc.new { |service| Chef::Config[:knife][:kerberos_service] = service }
-
-      option :keytab_file,
-        :short => "-i KEYTAB_FILE",
-        :long => "--keytab-file KEYTAB_FILE",
-        :description => "The Kerberos keytab file used for authentication",
-        :proc => Proc.new { |keytab| Chef::Config[:knife][:keytab_file] = keytab }
-
-      option :ca_trust_file,
-        :short => "-f CA_TRUST_FILE",
-        :long => "--ca-trust-file CA_TRUST_FILE",
-        :description => "The Certificate Authority (CA) trust file used for SSL transport",
-        :proc => Proc.new { |trust| Chef::Config[:knife][:ca_trust_file] = trust }
-
       def session
-        require 'em-winrm'
         session_opts = {}
         session_opts[:logger] = Chef::Log.logger if Chef::Log.level == :debug
         @session ||= begin
@@ -151,6 +97,7 @@ class Chef
           session_opts[:realm] = Chef::Config[:knife][:kerberos_realm] if Chef::Config[:knife][:kerberos_realm]
           session_opts[:service] = Chef::Config[:knife][:kerberos_service] if Chef::Config[:knife][:kerberos_service]
           session_opts[:ca_trust_path] = Chef::Config[:knife][:ca_trust_file] if Chef::Config[:knife][:ca_trust_file]
+          session_opts[:operation_timeout] = 1800 # 30 min OperationTimeout for long bootstraps fix for KNIFE_WINDOWS-8
 
           if config.keys.any? {|k| k.to_s =~ /kerberos/ }
             session_opts[:transport] = :kerberos
@@ -243,16 +190,28 @@ class Chef
       end
 
       def run
-        @longest = 0
+        STDOUT.sync = STDERR.sync = true
 
-        configure_session
+        begin
+          @longest = 0
 
-        case @name_args[1]
-        when "interactive"
-          interactive
-        else
-          winrm_command(@name_args[1..-1].join(" "))
-          session.close
+          configure_session
+
+          case @name_args[1]
+          when "interactive"
+            interactive
+          else
+            winrm_command(@name_args[1..-1].join(" "))
+            session.close
+          end
+        rescue WinRM::WinRMHTTPTransportError => e
+          case e.message
+          when /401/
+            ui.error "Failed to authenticate to #{@name_args[0].split(" ")} as #{config[:winrm_user]}"
+            ui.info "Response: #{e.message}"
+          else
+            raise e
+          end
         end
       end
 

data/lib/chef/knife/winrm_base.rb

@@ -0,0 +1,98 @@
+#
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/knife'
+require 'chef/encrypted_data_bag_item'
+
+class Chef
+  class Knife
+    module WinrmBase
+
+      # :nodoc:
+      # Would prefer to do this in a rational way, but can't be done b/c of
+      # Mixlib::CLI's design :(
+      def self.included(includer)
+        includer.class_eval do
+
+          deps do
+            require 'readline'
+            require 'chef/json_compat'
+          end
+
+          option :winrm_user,
+            :short => "-x USERNAME",
+            :long => "--winrm-user USERNAME",
+            :description => "The WinRM username",
+            :default => "Administrator",
+            :proc => Proc.new { |key| Chef::Config[:knife][:winrm_user] = key }
+
+          option :winrm_password,
+            :short => "-P PASSWORD",
+            :long => "--winrm-password PASSWORD",
+            :description => "The WinRM password",
+            :proc => Proc.new { |key| Chef::Config[:knife][:winrm_password] = key }
+
+          option :winrm_port,
+            :short => "-p PORT",
+            :long => "--winrm-port PORT",
+            :description => "The WinRM port, by default this is 5985",
+            :default => "5985",
+            :proc => Proc.new { |key| Chef::Config[:knife][:winrm_port] = key }
+
+          option :identity_file,
+            :short => "-i IDENTITY_FILE",
+            :long => "--identity-file IDENTITY_FILE",
+            :description => "The SSH identity file used for authentication"
+
+          option :winrm_transport,
+            :short => "-t TRANSPORT",
+            :long => "--winrm-transport TRANSPORT",
+            :description => "The WinRM transport type.  valid choices are [ssl, plaintext]",
+            :default => 'plaintext',
+            :proc => Proc.new { |transport| Chef::Config[:knife][:winrm_transport] = transport }
+
+          option :kerberos_keytab_file,
+            :short => "-i KEYTAB_FILE",
+            :long => "--keytab-file KEYTAB_FILE",
+            :description => "The Kerberos keytab file used for authentication",
+            :proc => Proc.new { |keytab| Chef::Config[:knife][:kerberos_keytab_file] = keytab }
+
+          option :kerberos_realm,
+            :short => "-R KERBEROS_REALM",
+            :long => "--kerberos-realm KERBEROS_REALM",
+            :description => "The Kerberos realm used for authentication",
+            :proc => Proc.new { |realm| Chef::Config[:knife][:kerberos_realm] = realm }
+
+          option :kerberos_service,
+            :short => "-S KERBEROS_SERVICE",
+            :long => "--kerberos-service KERBEROS_SERVICE",
+            :description => "The Kerberos service used for authentication",
+            :proc => Proc.new { |service| Chef::Config[:knife][:kerberos_service] = service }
+
+          option :ca_trust_file,
+            :short => "-f CA_TRUST_FILE",
+            :long => "--ca-trust-file CA_TRUST_FILE",
+            :description => "The Certificate Authority (CA) trust file used for SSL transport",
+            :proc => Proc.new { |trust| Chef::Config[:knife][:ca_trust_file] = trust }
+
+        end
+      end
+
+    end
+  end
+end

data/lib/knife-windows/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Windows
-    VERSION = "0.5.3"
+    VERSION = "0.5.4"
     MAJOR, MINOR, TINY = VERSION.split('.')
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: knife-windows
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors: 
 - Seth Chisamore
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-13 00:00:00 -07:00
+date: 2011-08-12 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,7 +21,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.0.5
+        version: 0.5.2
   type: :runtime
   version_requirements: *id001
 description: Plugin that adds functionality to Chef's Knife CLI for configuring/interacting with nodes running Microsoft Windows
@@ -36,17 +36,19 @@ extra_rdoc_files:
 - LICENSE
 files: 
 - .gitignore
+- CHANGELOG
 - Gemfile
 - LICENSE
 - README.rdoc
 - Rakefile
 - knife-windows.gemspec
 - lib/chef/knife/bootstrap/windows-shell.erb
+- lib/chef/knife/bootstrap_windows_base.rb
 - lib/chef/knife/bootstrap_windows_ssh.rb
 - lib/chef/knife/bootstrap_windows_winrm.rb
 - lib/chef/knife/core/windows_bootstrap_context.rb
-- lib/chef/knife/mixin/windows/bootstrap.rb
 - lib/chef/knife/winrm.rb
+- lib/chef/knife/winrm_base.rb
 - lib/knife-windows/version.rb
 has_rdoc: true
 homepage: https://github.com/opscode/knife-windows

data/lib/chef/knife/mixin/windows/bootstrap.rb

@@ -1,94 +0,0 @@
-require 'chef/knife'
-require 'erubis'
-
-class Chef
-  module Mixin
-    module Bootstrap
-
-      # TODO: This should go away when CHEF-2193 is fixed
-      def load_template(template=nil)
-        # Are we bootstrapping using an already shipped template?
-        if config[:template_file]
-          bootstrap_files = config[:template_file]
-        else
-          bootstrap_files = []
-          bootstrap_files << File.join(File.dirname(__FILE__), 'bootstrap', "#{config[:distro]}.erb")
-          bootstrap_files << File.join(Dir.pwd, ".chef", "bootstrap", "#{config[:distro]}.erb")
-          bootstrap_files << File.join(ENV['HOME'], '.chef', 'bootstrap', "#{config[:distro]}.erb")
-          bootstrap_files << Gem.find_files(File.join("chef","knife","bootstrap","#{config[:distro]}.erb"))
-          bootstrap_files.flatten!
-        end
-
-        template = Array(bootstrap_files).find do |bootstrap_template|
-          Chef::Log.debug("Looking for bootstrap template in #{File.dirname(bootstrap_template)}")
-          ::File.exists?(bootstrap_template)
-        end
-
-        unless template
-          ui.info("Can not find bootstrap definition for #{config[:distro]}")
-          raise Errno::ENOENT
-        end
-
-        Chef::Log.debug("Found bootstrap template in #{File.dirname(template)}")
-
-        IO.read(template).chomp
-      end
-
-      def render_template(template=nil)
-        context = Knife::Core::WindowsBootstrapContext.new(config, config[:run_list], Chef::Config)
-        Erubis::Eruby.new(template).evaluate(context)
-      end
-
-      def bootstrap(proto=nil)
-
-        validate_name_args!
-
-        @node_name = Array(@name_args).first
-        # back compat--templates may use this setting:
-        config[:server_name] = @node_name
-
-        $stdout.sync = true
-
-        ui.info("Bootstrapping Chef on #{ui.color(@node_name, :bold)}")
-        # create a bootstrap.bat file on the node
-        # we have to run the remote commands in 2047 char chunks
-        create_bootstrap_bat_command do |command_chunk, chunk_num|
-          run_command("cmd.exe /C echo \"Rendering bootstrap.bat chunk #{chunk_num}\" && #{command_chunk}").run
-        end
-
-        # execute the bootstrap.bat file
-        run_command(bootstrap_command).run
-      end
-
-      def bootstrap_command
-        @bootstrap_command ||= "cmd.exe /C #{bootstrap_bat_file}"
-      end
-
-      def create_bootstrap_bat_command(&block)
-        bootstrap_bat = []
-        chunk_num = 0
-        render_template(load_template(config[:bootstrap_template])).each_line do |line|
-          # escape WIN BATCH special chars
-          line.gsub!(/[(<|>)^]/).each{|m| "^#{m}"}
-          # windows commands are limited to 2047 characters
-          if((bootstrap_bat + [line]).join(" && ").size > 2047 )
-            yield bootstrap_bat.join(" && "), chunk_num += 1
-            bootstrap_bat = []
-          end
-          bootstrap_bat << ">> #{bootstrap_bat_file} (echo.#{line.chomp.strip})"
-        end
-        yield bootstrap_bat.join(" && "), chunk_num += 1
-      end
-
-      def bootstrap_bat_file
-        "%TEMP%\\bootstrap.bat"
-      end
-
-      def locate_config_value(key)
-        key = key.to_sym
-        Chef::Config[:knife][key] || config[key]
-      end
-
-    end
-  end
-end