winrm 1.2.0 → 1.3.0.dev.1

data/lib/winrm/winrm_service.rb

@@ -1,20 +1,19 @@
-=begin
-  This file is part of WinRM; the Ruby library for Microsoft WinRM.
-
-  Copyright © 2010 Dan Wanek <dan.wanek@gmail.com>
-
-  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.
-=end
+# Copyright 2010 Dan Wanek <dan.wanek@gmail.com>
+# 
+# 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 'nori'
+require 'rexml/document'
 
 module WinRM
   # This is the main class that does the SOAP request/response logic. There are a few helper classes, but pretty
@@ -36,17 +35,19 @@ module WinRM
     def initialize(endpoint, transport = :kerberos, opts = {})
       @endpoint = endpoint
       @timeout = DEFAULT_TIMEOUT
-      @max_env_sz = DEFAULT_MAX_ENV_SIZE 
+      @max_env_sz = DEFAULT_MAX_ENV_SIZE
       @locale = DEFAULT_LOCALE
+      @logger = Logging.logger[self]
       case transport
       when :kerberos
         require 'gssapi'
-        # TODO: check fo keys and throw error if missing
         @xfer = HTTP::HttpGSSAPI.new(endpoint, opts[:realm], opts[:service], opts[:keytab], opts)
       when :plaintext
         @xfer = HTTP::HttpPlaintext.new(endpoint, opts[:user], opts[:pass], opts)
       when :ssl
         @xfer = HTTP::HttpSSL.new(endpoint, opts[:user], opts[:pass], opts[:ca_trust_path], opts)
+      else
+        raise "Invalid transport '#{transport}' specified, expected: kerberos, plaintext, ssl."
       end
     end
 
@@ -85,33 +86,34 @@ module WinRM
       o_stream = shell_opts.has_key?(:o_stream) ? shell_opts[:o_stream] : 'stdout stderr'
       codepage = shell_opts.has_key?(:codepage) ? shell_opts[:codepage] : 437
       noprofile = shell_opts.has_key?(:noprofile) ? shell_opts[:noprofile] : 'FALSE'
-      s = Savon::SOAP::XML.new
-      s.version = 2
-      s.namespaces.merge!(namespaces)
       h_opts = { "#{NS_WSMAN_DMTF}:OptionSet" => { "#{NS_WSMAN_DMTF}:Option" => [noprofile, codepage],
         :attributes! => {"#{NS_WSMAN_DMTF}:Option" => {'Name' => ['WINRS_NOPROFILE','WINRS_CODEPAGE']}}}}
-      s.header.merge!(merge_headers(header,resource_uri_cmd,action_create,h_opts))
-      s.input = "#{NS_WIN_SHELL}:Shell"
-      s.body = {
+      shell_body = {
         "#{NS_WIN_SHELL}:InputStreams" => i_stream,
         "#{NS_WIN_SHELL}:OutputStreams" => o_stream
       }
-      s.body["#{NS_WIN_SHELL}:WorkingDirectory"] = shell_opts[:working_directory] if shell_opts.has_key?(:working_directory)
-      # TODO: research Lifetime a bit more: http://msdn.microsoft.com/en-us/library/cc251546(v=PROT.13).aspx
-      #s.body["#{NS_WIN_SHELL}:Lifetime"] = Iso8601Duration.sec_to_dur(shell_opts[:lifetime]) if(shell_opts.has_key?(:lifetime) && shell_opts[:lifetime].is_a?(Fixnum))
-      # @todo make it so the input is given in milliseconds and converted to xs:duration
-      s.body["#{NS_WIN_SHELL}:IdleTimeOut"] = shell_opts[:idle_timeout] if(shell_opts.has_key?(:idle_timeout) && shell_opts[:idle_timeout].is_a?(String))
+      shell_body["#{NS_WIN_SHELL}:WorkingDirectory"] = shell_opts[:working_directory] if shell_opts.has_key?(:working_directory)
+      shell_body["#{NS_WIN_SHELL}:IdleTimeOut"] = shell_opts[:idle_timeout] if(shell_opts.has_key?(:idle_timeout) && shell_opts[:idle_timeout].is_a?(String))
       if(shell_opts.has_key?(:env_vars) && shell_opts[:env_vars].is_a?(Hash))
         keys = shell_opts[:env_vars].keys
         vals = shell_opts[:env_vars].values
-        s.body["#{NS_WIN_SHELL}:Environment"] = {
+        shell_body["#{NS_WIN_SHELL}:Environment"] = {
           "#{NS_WIN_SHELL}:Variable" => vals,
           :attributes! => {"#{NS_WIN_SHELL}:Variable" => {'Name' => keys}}
         }
       end
+      builder = Builder::XmlMarkup.new
+      builder.instruct!(:xml, :encoding => 'UTF-8')
+      builder.tag! :env, :Envelope, namespaces do |env|
+        env.tag!(:env, :Header) { |h| h << Gyoku.xml(merge_headers(header,resource_uri_cmd,action_create,h_opts)) }
+        env.tag! :env, :Body do |body|
+          body.tag!("#{NS_WIN_SHELL}:Shell") { |s| s << Gyoku.xml(shell_body)}
+        end
+      end
 
-      resp = send_message(s.to_xml)
-      (resp/"//*[@Name='ShellId']").text
+      resp_doc = send_message(builder.target!)
+      shell_id = REXML::XPath.first(resp_doc, "//*[@Name='ShellId']").text
+      shell_id
     end
 
     # Run a command on a machine with an open shell
@@ -122,24 +124,53 @@ module WinRM
     def run_command(shell_id, command, arguments = [], cmd_opts = {})
       consolemode = cmd_opts.has_key?(:console_mode_stdin) ? cmd_opts[:console_mode_stdin] : 'TRUE'
       skipcmd     = cmd_opts.has_key?(:skip_cmd_shell) ? cmd_opts[:skip_cmd_shell] : 'FALSE'
-      s = Savon::SOAP::XML.new
-      s.version = 2
-      s.namespaces.merge!(namespaces)
+
       h_opts = { "#{NS_WSMAN_DMTF}:OptionSet" => {
         "#{NS_WSMAN_DMTF}:Option" => [consolemode, skipcmd],
         :attributes! => {"#{NS_WSMAN_DMTF}:Option" => {'Name' => ['WINRS_CONSOLEMODE_STDIN','WINRS_SKIP_CMD_SHELL']}}}
       }
-      s.header.merge!(merge_headers(header,resource_uri_cmd,action_command,h_opts,selector_shell_id(shell_id)))
-      s.input = "#{NS_WIN_SHELL}:CommandLine"
-      s.body = { "#{NS_WIN_SHELL}:Command" => "\"#{command}\"", "#{NS_WIN_SHELL}:Arguments" => arguments}
+      body = { "#{NS_WIN_SHELL}:Command" => "\"#{command}\"", "#{NS_WIN_SHELL}:Arguments" => arguments}
+
+      builder = Builder::XmlMarkup.new
+      builder.instruct!(:xml, :encoding => 'UTF-8')
+      builder.tag! :env, :Envelope, namespaces do |env|
+        env.tag!(:env, :Header) { |h| h << Gyoku.xml(merge_headers(header,resource_uri_cmd,action_command,h_opts,selector_shell_id(shell_id))) }
+        env.tag!(:env, :Body) do |env_body|
+          env_body.tag!("#{NS_WIN_SHELL}:CommandLine") { |cl| cl << Gyoku.xml(body) }
+        end
+      end
 
       # Grab the command element and unescape any single quotes - issue 69
-      xml = s.to_xml
+      xml = builder.target!
       escaped_cmd = /<#{NS_WIN_SHELL}:Command>(.+)<\/#{NS_WIN_SHELL}:Command>/.match(xml)[1]
       xml.sub!(escaped_cmd, escaped_cmd.gsub(/&#39;/, "'"))
 
-      resp = send_message(xml)
-      (resp/"//#{NS_WIN_SHELL}:CommandId").text
+      resp_doc = send_message(xml)
+      command_id = REXML::XPath.first(resp_doc, "//#{NS_WIN_SHELL}:CommandId").text
+      command_id
+    end
+
+    def write_stdin(shell_id, command_id, stdin)
+      # Signal the Command references to terminate (close stdout/stderr)
+      body = {
+        "#{NS_WIN_SHELL}:Send" => {
+          "#{NS_WIN_SHELL}:Stream" => {
+            "@Name" => 'stdin',
+            "@CommandId" => command_id,
+            :content! => Base64.encode64(stdin)
+          }
+        }
+      }
+      builder = Builder::XmlMarkup.new
+      builder.instruct!(:xml, :encoding => 'UTF-8')
+      builder.tag! :env, :Envelope, namespaces do |env|
+        env.tag!(:env, :Header) { |h| h << Gyoku.xml(merge_headers(header,resource_uri_cmd,action_send,selector_shell_id(shell_id))) }
+        env.tag!(:env, :Body) do |env_body|
+          env_body << Gyoku.xml(body)
+        end
+      end
+      resp = send_message(builder.target!)
+      true
     end
 
     # Get the Output of the given shell and command
@@ -149,19 +180,23 @@ module WinRM
     #   is either :stdout or :stderr.  The reason it is in an Array so so we can get the output in the order it ocurrs on
     #   the console.
     def get_command_output(shell_id, command_id, &block)
-      s = Savon::SOAP::XML.new
-      s.version = 2
-      s.namespaces.merge!(namespaces)
-      s.header.merge!(merge_headers(header,resource_uri_cmd,action_receive,selector_shell_id(shell_id)))
-      s.input = "#{NS_WIN_SHELL}:Receive"
-      s.body = { "#{NS_WIN_SHELL}:DesiredStream" => 'stdout stderr',
+      body = { "#{NS_WIN_SHELL}:DesiredStream" => 'stdout stderr',
         :attributes! => {"#{NS_WIN_SHELL}:DesiredStream" => {'CommandId' => command_id}}}
 
-      resp = send_message(s.to_xml)
+      builder = Builder::XmlMarkup.new
+      builder.instruct!(:xml, :encoding => 'UTF-8')
+      builder.tag! :env, :Envelope, namespaces do |env|
+        env.tag!(:env, :Header) { |h| h << Gyoku.xml(merge_headers(header,resource_uri_cmd,action_receive,selector_shell_id(shell_id))) }
+        env.tag!(:env, :Body) do |env_body|
+          env_body.tag!("#{NS_WIN_SHELL}:Receive") { |cl| cl << Gyoku.xml(body) }
+        end
+      end
+
+      resp_doc = send_message(builder.target!)
       output = {:data => []}
-      (resp/"//#{NS_WIN_SHELL}:Stream").each do |n|
+      REXML::XPath.match(resp_doc, "//#{NS_WIN_SHELL}:Stream").each do |n|
         next if n.text.nil? || n.text.empty?
-        stream = {n['Name'].to_sym => Base64.decode64(n.text)}
+        stream = { n.attributes['Name'].to_sym => Base64.decode64(n.text) }
         output[:data] << stream
         yield stream[:stdout], stream[:stderr] if block_given?
       end
@@ -175,12 +210,14 @@ module WinRM
       #   <rsp:CommandState CommandId="..." State="http://schemas.microsoft.com/wbem/wsman/1/windows/shell/CommandState/Done">
       #     <rsp:ExitCode>0</rsp:ExitCode>
       #   </rsp:CommandState>
-      if((resp/"//*[@State='http://schemas.microsoft.com/wbem/wsman/1/windows/shell/CommandState/Done']").empty?)
-        output.merge!(get_command_output(shell_id,command_id,&block)) do |key, old_data, new_data|
+      #if ((resp/"//*[@State='http://schemas.microsoft.com/wbem/wsman/1/windows/shell/CommandState/Done']").empty?)
+      done_elems = REXML::XPath.match(resp_doc, "//*[@State='http://schemas.microsoft.com/wbem/wsman/1/windows/shell/CommandState/Done']")
+      if done_elems.empty?
+        output.merge!(get_command_output(shell_id, command_id, &block)) do |key, old_data, new_data|
           old_data += new_data
         end
       else
-        output[:exitcode] = (resp/"//#{NS_WIN_SHELL}:ExitCode").text.to_i
+        output[:exitcode] = REXML::XPath.first(resp_doc, "//#{NS_WIN_SHELL}:ExitCode").text.to_i
       end
       output
     end
@@ -191,16 +228,17 @@ module WinRM
     # @param [String] command_id The command id on the remote machine.  See #run_command
     # @return [true] This should have more error checking but it just returns true for now.
     def cleanup_command(shell_id, command_id)
-      s = Savon::SOAP::XML.new
-      s.version = 2
-      s.namespaces.merge!(namespaces)
-      s.header.merge!(merge_headers(header,resource_uri_cmd,action_signal,selector_shell_id(shell_id)))
-
       # Signal the Command references to terminate (close stdout/stderr)
-      s.input = ["#{NS_WIN_SHELL}:Signal", {'CommandId' => command_id}]
-
-      s.body = { "#{NS_WIN_SHELL}:Code" => 'http://schemas.microsoft.com/wbem/wsman/1/windows/shell/signal/terminate' }
-      resp = send_message(s.to_xml)
+      body = { "#{NS_WIN_SHELL}:Code" => 'http://schemas.microsoft.com/wbem/wsman/1/windows/shell/signal/terminate' }
+      builder = Builder::XmlMarkup.new
+      builder.instruct!(:xml, :encoding => 'UTF-8')
+      builder.tag! :env, :Envelope, namespaces do |env|
+        env.tag!(:env, :Header) { |h| h << Gyoku.xml(merge_headers(header,resource_uri_cmd,action_signal,selector_shell_id(shell_id))) }
+        env.tag!(:env, :Body) do |env_body|
+          env_body.tag!("#{NS_WIN_SHELL}:Signal", {'CommandId' => command_id}) { |cl| cl << Gyoku.xml(body) }
+        end
+      end
+      resp = send_message(builder.target!)
       true
     end
 
@@ -208,31 +246,15 @@ module WinRM
     # @param [String] shell_id The shell id on the remote machine.  See #open_shell
     # @return [true] This should have more error checking but it just returns true for now.
     def close_shell(shell_id)
-      s = Savon::SOAP::XML.new
-      s.version = 2
-      s.namespaces.merge!(namespaces)
-      s.namespaces.merge!(Savon::SOAP::XML::SchemaTypes)
-      s.header.merge!(merge_headers(header,resource_uri_cmd,action_delete,selector_shell_id(shell_id)))
-
-      # Because Savon does not support a nil Body we have to build it ourselves.
-      s.xml do |b|
-        b.tag!('env:Envelope', s.namespaces) do
-          b.tag!('env:Header') do |bh|
-            bh << Gyoku.xml(s.header) unless s.header.empty?
-          end
-          if(s.input.nil?)
-            b.tag! 'env:Body'
-          else
-            b.tag! 'env:Body' do |bb|
-              bb.tag! s.input do |bbb|
-                bbb << Gyoku.xml(s.body) if s.body
-              end
-            end
-          end
-        end
+      builder = Builder::XmlMarkup.new
+      builder.instruct!(:xml, :encoding => 'UTF-8')
+
+      builder.tag!('env:Envelope', namespaces) do |env|
+        env.tag!('env:Header') { |h| h << Gyoku.xml(merge_headers(header,resource_uri_cmd,action_delete,selector_shell_id(shell_id))) }
+        env.tag!('env:Body')
       end
 
-      resp = send_message(s.to_xml)
+      resp = send_message(builder.target!)
       true
     end
 
@@ -274,28 +296,35 @@ module WinRM
     # @param [String] wql The WQL query
     # @return [Hash] Returns a Hash that contain the key/value pairs returned from the query.
     def run_wql(wql)
-      s = Savon::SOAP::XML.new
-      s.version = 2
-      s.namespaces.merge!(namespaces)
-      s.header.merge!(merge_headers(header,resource_uri_wmi,action_enumerate))
-      s.input = "#{NS_ENUM}:Enumerate"
-      s.body = { "#{NS_WSMAN_DMTF}:OptimizeEnumeration" => nil,
+
+      body = { "#{NS_WSMAN_DMTF}:OptimizeEnumeration" => nil,
         "#{NS_WSMAN_DMTF}:MaxElements" => '32000',
         "#{NS_WSMAN_DMTF}:Filter" => wql,
         :attributes! => { "#{NS_WSMAN_DMTF}:Filter" => {'Dialect' => 'http://schemas.microsoft.com/wbem/wsman/1/WQL'}}
       }
 
-      resp = send_message(s.to_xml)
-      toggle_nori_type_casting :off
-      hresp = Nori.parse(resp.to_xml)[:envelope][:body]
-      toggle_nori_type_casting :original
+      builder = Builder::XmlMarkup.new
+      builder.instruct!(:xml, :encoding => 'UTF-8')
+      builder.tag! :env, :Envelope, namespaces do |env|
+        env.tag!(:env, :Header) { |h| h << Gyoku.xml(merge_headers(header,resource_uri_wmi,action_enumerate)) }
+        env.tag!(:env, :Body) do |env_body|
+          env_body.tag!("#{NS_ENUM}:Enumerate") { |en| en << Gyoku.xml(body) }
+        end
+      end
+
+      resp = send_message(builder.target!)
+      parser = Nori.new(:parser => :rexml, :advanced_typecasting => false, :convert_tags_to => lambda { |tag| tag.snakecase.to_sym }, :strip_namespaces => true)
+      hresp = parser.parse(resp.to_s)[:envelope][:body]
+      
       # Normalize items so the type always has an array even if it's just a single item.
       items = {}
-      hresp[:enumerate_response][:items].each_pair do |k,v|
-        if v.is_a?(Array)
-          items[k] = v
-        else
-          items[k] = [v]
+      if hresp[:enumerate_response][:items]
+        hresp[:enumerate_response][:items].each_pair do |k,v|
+          if v.is_a?(Array)
+            items[k] = v
+          else
+            items[k] = [v]
+          end
         end
       end
       items
@@ -303,24 +332,18 @@ module WinRM
     alias :wql :run_wql
 
     def toggle_nori_type_casting(to)
-      @nori_type_casting ||= Nori.advanced_typecasting?
-      case to.to_sym
-      when :original
-        Nori.advanced_typecasting = @nori_type_casting
-      when :on
-        Nori.advanced_typecasting = true
-      when :off
-        Nori.advanced_typecasting = false
-      else
-        raise ArgumentError, "Cannot toggle type casting to '#{to}', it is not a valid argument"
-      end
-
+      @logger.warn('toggle_nori_type_casting is deprecated and has no effect, ' +
+        'please remove calls to it')
     end
 
     private
 
     def namespaces
-      {'xmlns:a' => 'http://schemas.xmlsoap.org/ws/2004/08/addressing',
+      {
+        'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+        'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+        'xmlns:env' => 'http://www.w3.org/2003/05/soap-envelope',
+        'xmlns:a' => 'http://schemas.xmlsoap.org/ws/2004/08/addressing',
         'xmlns:b' => 'http://schemas.dmtf.org/wbem/wsman/1/cimbinding.xsd',
         'xmlns:n' => 'http://schemas.xmlsoap.org/ws/2004/09/enumeration',
         'xmlns:x' => 'http://schemas.xmlsoap.org/ws/2004/09/transfer',
@@ -340,7 +363,6 @@ module WinRM
         "#{NS_ADDRESSING}:MessageID" => "uuid:#{UUIDTools::UUID.random_create.to_s.upcase}",
         "#{NS_WSMAN_DMTF}:Locale/" => '',
         "#{NS_WSMAN_MSFT}:DataLocale/" => '',
-        #"#{NS_WSMAN_CONF}:MaxTimeoutms" => 600, #TODO: research this a bit http://msdn.microsoft.com/en-us/library/cc251561(v=PROT.13).aspx
         "#{NS_WSMAN_DMTF}:OperationTimeout" => @timeout,
         :attributes! => {
           "#{NS_WSMAN_DMTF}:MaxEnvelopeSize" => {'mustUnderstand' => true},
@@ -362,23 +384,9 @@ module WinRM
     end
 
     def send_message(message)
-      resp = @xfer.send_request(message)
-
-      begin
-        errors = resp/"//#{NS_SOAP_ENV}:Body/#{NS_SOAP_ENV}:Fault/*"
-        if errors.empty?
-          return resp
-        else
-          resp.root.add_namespace(NS_WSMAN_FAULT,'http://schemas.microsoft.com/wbem/wsman/1/wsmanfault')
-          fault = (errors/"//#{NS_WSMAN_FAULT}:WSManFault").first
-          raise WinRMWSManFault, "[WSMAN ERROR CODE: #{fault['Code']}]: #{fault.text}"
-        end
-      # Sometimes a blank response is returned and it will throw this error when the XPath is evaluated for Fault
-      # The returned string will be '<?xml version="1.0"?>\n' in these cases
-      rescue Nokogiri::XML::XPath::SyntaxError => e
-        raise WinRMWebServiceError, "Bad SOAP Packet returned. Sometimes a retry will solve this error."
-      end
+      @xfer.send_request(message)
     end
+    
 
     # Helper methods for SOAP Headers
 
@@ -417,13 +425,18 @@ module WinRM
         :attributes! => {"#{NS_ADDRESSING}:Action" => {'mustUnderstand' => true}}}
     end
 
+    def action_send
+      {"#{NS_ADDRESSING}:Action" => 'http://schemas.microsoft.com/wbem/wsman/1/windows/shell/Send',
+        :attributes! => {"#{NS_ADDRESSING}:Action" => {'mustUnderstand' => true}}}
+    end
+
     def action_enumerate
       {"#{NS_ADDRESSING}:Action" => 'http://schemas.xmlsoap.org/ws/2004/09/enumeration/Enumerate',
         :attributes! => {"#{NS_ADDRESSING}:Action" => {'mustUnderstand' => true}}}
     end
 
     def selector_shell_id(shell_id)
-      {"#{NS_WSMAN_DMTF}:SelectorSet" => 
+      {"#{NS_WSMAN_DMTF}:SelectorSet" =>
         {"#{NS_WSMAN_DMTF}:Selector" => shell_id, :attributes! => {"#{NS_WSMAN_DMTF}:Selector" => {'Name' => 'ShellId'}}}
       }
     end

data/lib/winrm.rb

@@ -1,28 +1,36 @@
-=begin
-  This file is part of WinRM; the Ruby library for Microsoft WinRM.
-
-  Copyright © 2010 Dan Wanek <dan.wanek@gmail.com>
-
-  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.
-=end
+# Copyright 2010 Dan Wanek <dan.wanek@gmail.com>
+# 
+# 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 'date'
 require 'kconv' # rubyntlm .0.1.1 doesn't require kconv, workaround for issue #65
 require 'logging'
 
 module WinRM
-  Logging.logger.root.level = :info
-  Logging.logger.root.appenders = Logging.appenders.stdout
+  # Enable logging if it is requested. We do this before
+  # anything else so that we can setup the output before
+  # any logging occurs.
+  if ENV["WINRM_LOG"] && ENV["WINRM_LOG"] != ""
+    begin
+      Logging.logger.root.level = ENV["WINRM_LOG"]
+      Logging.logger.root.appenders = Logging.appenders.stderr
+    rescue ArgumentError
+      # This means that the logging level wasn't valid
+      $stderr.puts "Invalid WINRM_LOG level is set: #{ENV["WINRM_LOG"]}"
+      $stderr.puts ""
+      $stderr.puts "Please use one of the standard log levels: debug, info, warn, or error"
+    end
+  end
 end
 
 require 'winrm/helpers/iso8601_duration'

data/spec/auth_timeout_spec.rb

@@ -0,0 +1,15 @@
+# This test may only be meaningful with kerberos auth
+# Against server 2012, a kerberos connection will require reauth (get a 401)
+# if there are no requests for >= 15 seconds
+
+describe "Verify kerberos will reauth when necessary", :kerberos => true do
+  before(:all) do
+    @winrm = winrm_connection
+  end
+
+  it 'work with a 18 second sleep' do
+    ps_command = 'Start-Sleep -s 18'
+    output = @winrm.run_powershell_script(ps_command)
+    output[:exitcode].should == 0
+  end
+end

data/spec/cmd_spec.rb

@@ -1,36 +1,58 @@
-describe "Test remote WQL features via WinRM", :integration => true do
+describe 'winrm client cmd', :integration => true do
   before(:all) do
     @winrm = winrm_connection
   end
 
-  it 'should run a CMD command string' do
-    output = @winrm.run_cmd('ipconfig /all')
-    expect(output[:exitcode]).to eq(0)
-    expect(output[:data]).to_not be_empty
+  describe 'empty string' do
+    subject(:output) { @winrm.cmd('') }
+    it { should have_exit_code 0 }
+    it { should have_no_stdout }
+    it { should have_no_stderr }
   end
 
-  it 'should run a CMD command with proper arguments' do
-    output = @winrm.run_cmd('ipconfig', %w{/all})
-    expect(output[:exitcode]).to eq(0)
-    expect(output[:data]).to_not be_empty
+  describe 'ipconfig' do
+    subject(:output) { @winrm.cmd('ipconfig') }
+    it { should have_exit_code 0 }
+    it { should have_stdout_match /Windows IP Configuration/ }
+    it { should have_no_stderr }
   end
 
-  it 'should run a CMD command with block' do
-    outvar = ''
-    @winrm.run_cmd('ipconfig', %w{/all}) do |stdout, stderr|
-      outvar << stdout
-    end
-    expect(outvar).to match(/Windows IP Configuration/)
+  describe 'echo \'hello world\' using apostrophes' do
+    subject(:output) { @winrm.cmd("echo 'hello world'") }
+    it { should have_exit_code 0 }
+    it { should have_stdout_match /'hello world'/ }
+    it { should have_no_stderr }
+  end
+
+  describe 'ipconfig with /all argument' do
+    subject(:output) { @winrm.cmd('ipconfig', %w{/all}) }
+    it { should have_exit_code 0 }
+    it { should have_stdout_match /Windows IP Configuration/ }
+    it { should have_no_stderr }
   end
 
-  it 'should run a CMD command that contains an apostrophe' do
-    output = @winrm.run_cmd(%q{echo 'hello world'})
-    expect(output[:exitcode]).to eq(0)
-    expect(output[:data][0][:stdout]).to match(/'hello world'/)
+  describe 'dir with incorrect argument /z' do
+    subject(:output) { @winrm.cmd('dir /z') }
+    it { should have_exit_code 1 }
+    it { should have_no_stdout }
+    it { should have_stderr_match /Invalid switch/ }
   end
 
-  it 'should run a CMD command that is empty' do
-    output = @winrm.run_cmd('')
-    expect(output[:exitcode]).to eq(0)
+  describe 'ipconfig && echo error 1>&2' do
+    subject(:output) { @winrm.cmd('ipconfig && echo error 1>&2') }
+    it { should have_exit_code 0 }
+    it { should have_stdout_match /Windows IP Configuration/ }
+    it { should have_stderr_match /error/ }
+  end
+
+  describe 'ipconfig with a block' do
+    subject(:stdout) do
+      outvar = ''
+      @winrm.cmd('ipconfig') do |stdout, stderr|
+        outvar << stdout
+      end
+      outvar
+    end
+    it { should match(/Windows IP Configuration/) }
   end
 end

data/spec/exception_spec.rb

@@ -0,0 +1,35 @@
+describe "Exceptions", :unit => true do
+  describe WinRM::WinRMAuthorizationError do
+
+    let (:error) { WinRM::WinRMHTTPTransportError.new("Foo happened", 500) }
+
+    it 'adds the response code to the message' do
+      expect(error.message).to eq('Foo happened (500).')
+    end
+
+    it 'exposes the response code as an attribute' do
+      expect(error.status_code).to eq 500
+    end
+
+    it 'is a winrm error' do
+      expect(error).to be_kind_of(WinRM::WinRMError)
+    end
+  end
+
+  describe WinRM::WinRMWSManFault do
+
+    let (:error) { WinRM::WinRMWSManFault.new("fault text", 42) }
+
+    it 'exposes the fault text as an attribute' do
+      expect(error.fault_description).to eq('fault text')
+    end
+
+    it 'exposes the fault code as an attribute' do
+      expect(error.fault_code).to eq 42
+    end
+
+    it 'is a winrm error' do
+      expect(error).to be_kind_of(WinRM::WinRMError)
+    end
+  end
+end