vagrant-windows 1.0.3 → 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cecfc851c351d99894540e03b595c9ed93fb313b
+  data.tar.gz: 325c6d920df52dc61f4db48e64337b88480a1b0d
+SHA512:
+  metadata.gz: c5d93cd182875294ee9c50911b272363752039d8ab1ccae5c620291b109eb7c04a3ec8073901982e64fa040b04678197936fc8f2fe97d925ebb71fb8c230c438
+  data.tar.gz: 9932265ce43b14f7b942146291e1696d861c2070d8b79b147bda0b02bc4e41ac486b8996e20fac232802ddea0b083f276e2dddd7f7692cd5e49a711033fc2582

data/.gitignore

@@ -17,3 +17,4 @@ test/version_tmp
 tmp
 .vagrant
 Vagrantfile
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.9.2
+  - 2.0.0

data/Gemfile

@@ -7,5 +7,5 @@ group :development do
   # We depend on Vagrant for development, but we don't add it as a
   # gem dependency because we expect to be installed within the
   # Vagrant environment itself using `vagrant plugin`.
-  gem "vagrant", :git => "git://github.com/mitchellh/vagrant.git", :tag => 'v1.1.5'
+  gem "vagrant", :git => "git://github.com/mitchellh/vagrant.git", :tag => 'v1.2.2'
 end

data/README.md

@@ -1,9 +1,19 @@
 Installing Vagrant-Windows
 ==========================
 
-- Vagrant 1.0 should use <code>gem "vagrant-windows", "~> 0.1.2"</code>
-- Vagrant 1.1 should use <code>gem "vagrant-windows", "~> 1.0.0"</code>
-- Vagrant 1.2 is not yet supported. There needs to be a refactor to support capabilities. We are looking for a backwards compatiable way to implement this.
+For Vagrant 1.1.x and 1.2.x execute `vagrant plugin install vagrant-windows`.
+For Vagrant 1.0.x execute `vagrant plugin install vagrant-windows --plugin-version 0.1.2`.
+
+### Installing Vagrant-Windows From Source
+If you want to install from source, use the following method (this would be for 1.2.0):
+
+```
+ bundle install
+ bundle exec rake
+ vagrant plugin install pkg/vagrant-windows-1.2.0.gem
+```
+
+Keep in mind you should have Ruby 1.9.3 and Ruby DevKit installed. Check out the following gist that can get you what you need (from blank system to fully ready): [Install Vagrant Windows Plugin From Source Gist](https://gist.github.com/ferventcoder/6251225).
 
 Supported Guest Operating Systems (Your VM)
 ===========================================
@@ -20,7 +30,24 @@ Building a Base Box
 
 All Windows Machines
 -------------------- 
-  -Enable WinRM
+#### Prerequisites
+
+Box setup:
+
+  - Create a vagrant user, for things to work out of the box username and password should both be "vagrant".
+  - Turn off UAC (Msconfig)
+  - Disable complex passwords
+
+Prior to enabling WinRM, you must ensure the following services are enabled:
+
+  - Base Filtering Engine
+    - Remote Procedure Call (RPC)
+      - DCOM Server Process Launcher
+      - RPC Endpoint Mapper
+  - Windows Firewall
+  - Windows Remote Management (WS-Management)
+
+#### Enable WinRM
 ```
    winrm quickconfig -q
    winrm set winrm/config/winrs @{MaxMemoryPerShellMB="512"}
@@ -28,12 +55,21 @@ All Windows Machines
    winrm set winrm/config/service @{AllowUnencrypted="true"}
    winrm set winrm/config/service/auth @{Basic="true"}
 ```
-  - Create a vagrant user, for things to work out of the box username and password should both be "vagrant".
-  - Turn off UAC (Msconfig)
-  - Disable complex passwords
+* note
+If you want to run the winrm commands from PowerShell you need to put ```@{MaxMemoryPerShellMB="512"}``` etc in single quotes:
+
+```
+   winrm set winrm/config/winrs '@{MaxMemoryPerShellMB="512"}'
+```
+
+#### Last steps 
+
+  - Optional: Start WinRM a few minutes faster by running: "sc config WinRM start= auto" (default is delayed-auto)
+    - _Note:_ When you use the `winrm` command line tool it will always ask to set the startup to Delayed, so you may find yourself performing this a few times.
+
   
-Servers
---------
+Windows 2008/2012 Servers (except Core)
+---------------------------------------
   - [Disable Shutdown Tracker](http://www.jppinto.com/2010/01/how-to-disable-the-shutdown-event-tracker-in-server-20032008/)
   - [Disable "Server Manager" Starting at login](http://www.elmajdal.net/win2k8/How_to_Turn_Off_The_Automatic_Display_of_Server_Manager_At_logon.aspx)
   
@@ -44,7 +80,7 @@ Add the following to your Vagrantfile
 
 ```ruby
 config.vm.guest = :windows
-config.windows.halt_timeout = 15
+config.windows.halt_timeout = 25
 config.winrm.username = "vagrant"
 config.winrm.password = "vagrant"
 config.vm.network :forwarded_port, guest: 5985, host: 5985
@@ -55,7 +91,7 @@ Example:
 Vagrant.configure("2") do |config|
   
   # Max time to wait for the guest to shutdown
-  config.windows.halt_timeout = 15
+  config.windows.halt_timeout = 25
   
   # Admin user name and password
   config.winrm.username = "vagrant"
@@ -77,12 +113,13 @@ Available Config Parameters:
 
 * ```config.windows.halt_timeout``` - How long Vagrant should wait for the guest to shutdown before forcing exit, defaults to 30 seconds
 * ```config.windows.halt_check_interval``` - How often Vagrant should check if the system has shutdown, defaults to 1 second
+* ```config.windows.set_work_network``` - Force network adapters to "Work Network". Useful for Win7 guests using private networking.
 * ```config.winrm.username``` - The Windows guest admin user name, defaults to vagrant.
 * ```config.winrm.password``` - The above's password, defaults to vagrant.
 * ```config.winrm.host``` - The IP of the guest, but because we use NAT with port forwarding this defaults to localhost.
 * ```config.winrm.guest_port``` - The guest's WinRM port, defaults to 5985.
 * ```config.winrm.port``` - The WinRM port on the host, defaults to 5985. You might need to change this if your hosts is also Windows.
-* ```config.winrm.max_tries``` - The number of retries to connect to WinRM, defaults to 12.
+* ```config.winrm.max_tries``` - The number of retries to connect to WinRM, defaults to 20.
 * ```config.winrm.timeout``` - The max number of seconds to wait for a WinRM response, defaults to 1800 seconds.
 
 Note - You need to ensure you specify a config.windows and a config.winrm in your Vagrantfile. Currently there's a problem where
@@ -99,8 +136,7 @@ What Works?
 TODOs
 =========
 1. Test it! We need to test on more hosts, guests, and VBox versions. Help wanted.
-2. Vagrant 1.2 support. Unfortunately it appears there are some breaking changes with guests between Vagrant 1.1. and 1.2.
-3. Chef-Client support.
+2. Chef-Client support.
 3. Unit tests. 
 4. Better docs.
 
@@ -142,7 +178,7 @@ Contributing
 4. Push to the branch (git push origin my_feature_branch)
 5. Create a pull requst from your branch into master (Please be sure to provide enough detail for us to cipher what this change is doing)
 
-Running tests
+Development
 =============
 Clone this repository and use [Bundler](http://gembundler.com) to get the dependencies:
 
@@ -153,15 +189,32 @@ $ bundle install
 Once you have the dependencies, you can run the tests with `rake`:
 
 ```
-$ rake spec
+$ bundle exec rake spec
 ```
 
+If those pass, you're ready to start developing the plugin. You can test
+the plugin without installing it into your Vagrant environment by just
+creating a [Vagrantfile](http://docs.vagrantup.com/v2/plugins/packaging.html)
+in the top level of this directory (it is gitignored) that uses it, and
+use bundler to execute Vagrant:
+
+```
+$ bundle exec vagrant up
+```
+
+
 References and Shout Outs
 =========================
 - Chris McClimans - Vagrant Branch (https://github.com/hh/vagrant/blob/feature/winrm/)
 - Dan Wanek - WinRM GEM (https://github.com/zenchild/WinRM)
   - +1 For being super responsive to pull requests.
-
+- Mike Griffen - Added first vagrant-windows unit tests and updated readme
+- Geronimo Orozco - Shell provisioner support
+- David Cournapeau - Added config.windows.set_work_network option
+- keiths-osc - Fixed Vagrant 1.2 shared folder action
+- Rob Reynolds - Updated readme installation and box configuration notes
+- stonith - Updated readme winrm config notes
+- wenns - Updated readme to advise against forwarding RDP
 
 Changelog
 =========
@@ -188,8 +241,12 @@ Changelog
 
 1.0.3 
 
-- Added vagrant shell provisioner. 
-          The built-in shell provisioner tried to chmod the target script which doesn't make sense on windows.
-
+- Added vagrant shell provisioner. The built-in shell provisioner tried to chmod the target script which doesn't make sense on windows.
 - Can now run the vagrant-windows plugin via bundle exec instead of vagrant plugin install (for plugin dev).The vagrant src root finding logic didn't work from a bundle, but the native Vagrant src root does.
 - Readme fixes/updates.
+
+1.2.0
+
+- Converted to Vagrant 1.2.x plugin architecture.
+- Various networking fixes.
+- Chef provisioner runs through the Windows task scheduler instead of ps_runas power shell script.

data/Rakefile

@@ -8,8 +8,18 @@ Dir.chdir(File.expand_path("../", __FILE__))
 # For gem creation and bundling
 require "bundler/gem_tasks"
 
-# Install the `spec` task so that we can run tests.
-RSpec::Core::RakeTask.new
+# Run the unit test suite
+RSpec::Core::RakeTask.new do |task|
+    task.pattern = "spec/**/*_spec.rb"
+    task.rspec_opts = [ '--color', '-f documentation' ]
+    task.rspec_opts << '-tunit'
+end
 
-# Default task is to run the unit tests
-task :default => "build"
+# Run the integration test suite
+RSpec::Core::RakeTask.new(:integration) do |task|
+    task.pattern = "spec/**/*_spec.rb"
+    task.rspec_opts = [ '--color', '-f documentation' ]
+end
+
+# Default task is to run tests
+task :default => "spec"

data/lib/vagrant-windows/communication/guestnetwork.rb

@@ -0,0 +1,133 @@
+require 'log4r'
+require_relative '../../vagrant-windows'
+require_relative '../communication/winrmshell'
+require_relative '../errors'
+
+module VagrantWindows
+  module Communication
+    
+    # Manages the remote Windows guest network
+    class GuestNetwork
+      
+      PS_GET_WSMAN_VER = '((test-wsman).productversion.split(" ") | select -last 1).split("\.")[0]'
+      WQL_NET_ADAPTERS_V2 = 'SELECT * FROM Win32_NetworkAdapter WHERE MACAddress IS NOT NULL'
+
+      attr_reader :logger
+      attr_reader :winrmshell
+
+      def initialize(winrmshell)
+        @logger = Log4r::Logger.new("vagrant_windows::communication::winrmshell")
+        @logger.debug("initializing WinRMShell")
+        @winrmshell = winrmshell
+      end
+      
+      # Returns an array of all NICs on the guest. Each array entry is a
+      # Hash of the NICs properties.
+      #
+      # @return [Array]
+      def network_adapters()
+        wsman_version() == 2? network_adapters_v2_winrm() : network_adapters_v3_winrm()       
+      end
+      
+      # Checks to see if the specified NIC is currently configured for DHCP.
+      #
+      # @return [Boolean]
+      def is_dhcp_enabled(nic_index)
+        has_dhcp_enabled = false
+        cmd = "Get-WmiObject -Class Win32_NetworkAdapterConfiguration -Filter \"Index=#{nic_index} and DHCPEnabled=True\""
+        @winrmshell.powershell(cmd) do |type, line|
+          has_dhcp_enabled = !line.nil?
+        end
+        @logger.debug("NIC #{nic_index} has DHCP enabled: #{has_dhcp_enabled}")
+        has_dhcp_enabled
+      end
+      
+      # Configures the specified interface for DHCP
+      #
+      # @param [Integer] The interface index.
+      # @param [String] The unique name of the NIC, such as 'Local Area Connection'.
+      def configure_dhcp_interface(nic_index, net_connection_id)
+        @logger.info("Configuring NIC #{net_connection_id} for DHCP")
+        if !is_dhcp_enabled(nic_index)
+          netsh = "netsh interface ip set address \"#{net_connection_id}\" dhcp"
+          @winrmshell.powershell(netsh)
+        end
+      end
+      
+      # Configures the specified interface using a static address
+      #
+      # @param [Integer] The interface index.
+      # @param [String] The unique name of the NIC, such as 'Local Area Connection'.
+      # @param [String] The static IP address to assign to the specified NIC.
+      # @param [String] The network mask to use with the static IP.
+      def configure_static_interface(nic_index, net_connection_id, ip, netmask)
+        @logger.info("Configuring NIC #{net_connection_id} using static ip #{ip}")
+        #netsh interface ip set address "Local Area Connection 2" static 192.168.33.10 255.255.255.0
+        netsh = "netsh interface ip set address \"#{net_connection_id}\" static #{ip} #{netmask}"
+        @winrmshell.powershell(netsh)
+      end
+      
+      # Sets all networks on the guest to 'Work Network' mode. This is
+      # to allow guest access from the host via a private IP on Win7
+      # https://github.com/WinRb/vagrant-windows/issues/63
+      def set_all_networks_to_work()
+        @logger.info("Setting all networks to 'Work Network'")
+        command = VagrantWindows.load_script("set_work_network.ps1")
+        @winrmshell.powershell(command)
+      end
+      
+
+      protected
+      
+      # Checks the WinRS version on the guest. Usually 2 on Windows 7/2008
+      # and 3 on Windows 8/2012.
+      #
+      # @return [Integer]
+      def wsman_version()
+        @logger.debug("querying WSMan version")
+        version = ''
+        @winrmshell.powershell(PS_GET_WSMAN_VER) do |type, line|
+          version = version + "#{line}" if type == :stdout && !line.nil?
+        end
+        @logger.debug("wsman version: #{version}")
+        Integer(version)
+      end
+      
+      # Returns an array of all NICs on the guest. Each array entry is a
+      # Hash of the NICs properties. This method should only be used on
+      # guests that have WinRS version 2.
+      #
+      # @return [Array]
+      def network_adapters_v2_winrm()
+        @logger.debug("querying network adapters")
+        # Get all NICs that have a MAC address
+        # http://msdn.microsoft.com/en-us/library/windows/desktop/aa394216(v=vs.85).aspx
+        adapters = @winrmshell.wql(WQL_NET_ADAPTERS_V2)[:win32_network_adapter]
+        @logger.debug("#{adapters.inspect}")
+        return adapters
+      end
+      
+      # Returns an array of all NICs on the guest. Each array entry is a
+      # Hash of the NICs properties. This method should only be used on
+      # guests that have WinRS version 3.
+      #
+      # This method is a workaround until the WinRM gem supports WinRS version 3.
+      #
+      # @return [Array]
+      def network_adapters_v3_winrm()
+        winrs_v3_get_adapters_ps1 = VagrantWindows.load_script("winrs_v3_get_adapters.ps1")
+        output = ''
+        @winrmshell.powershell(winrs_v3_get_adapters_ps1) do |type, line|
+          output = output + "#{line}" if type == :stdout && !line.nil?
+        end
+        adapters = []
+        JSON.parse(output).each do |nic|
+          adapters << nic.inject({}){ |memo,(k,v)| memo[k.to_sym] = v; memo }
+        end          
+        @logger.debug("#{adapters.inspect}")
+        return adapters
+      end
+        
+    end #GuestNetwork class
+  end
+end

data/lib/vagrant-windows/communication/winrmcommunicator.rb

@@ -1,21 +1,17 @@
 require 'timeout'
-require 'winrm'
 require 'log4r'
-require 'vagrant/util/ansi_escape_code_remover'
-require 'vagrant/util/file_mode'
-require 'vagrant/util/platform'
-require 'vagrant/util/retryable'
+require_relative '../errors'
+require_relative 'winrmshell'
+require_relative 'winrmfinder'
 
 module VagrantWindows
   module Communication
     # Provides communication with the VM via WinRM.
     class WinRMCommunicator < Vagrant.plugin("2", :communicator)
 
-      include Vagrant::Util::ANSIEscapeCodeRemover
-      include Vagrant::Util::Retryable
-
       attr_reader :logger
       attr_reader :machine
+      attr_reader :winrm_finder
       
       def self.match?(machine)
         machine.config.vm.guest.eql? :windows
@@ -25,85 +21,44 @@ module VagrantWindows
         @machine = machine
         @logger = Log4r::Logger.new("vagrant_windows::communication::winrmcommunicator")
         @logger.debug("initializing WinRMCommunicator")
+        @winrm_finder = WinRMFinder.new(machine)
       end
 
       def ready?
         logger.debug("Checking whether WinRM is ready...")
-        
+
         Timeout.timeout(@machine.config.winrm.timeout) do
-          execute("hostname") do |type, data|
-            @logger.debug("hostname: #{data}")
-          end
+          session.powershell("hostname")
         end
 
-        # If we reached this point then we successfully connected
-        logger.debug("WinRM is ready!")
-        true
+        logger.info("WinRM is ready!")
+        return true
+        
+      rescue Vagrant::Errors::VagrantError => e
+        # We catch a `VagrantError` which would signal that something went
+        # wrong expectedly in the `connect`, which means we didn't connect.
+        @logger.info("WinRM not up: #{e.inspect}")
+        return false
       end
       
-      def execute(command, opts=nil, &block)
-        opts = {
-          :error_check => true,
-          :error_class => Errors::WinRMExecutionError,
-          :error_key   => :winrm_bad_exit_status,
-          :command     => command,
-          :sudo        => false,
-          :shell       => :powershell
-        }.merge(opts || {})
-
-        if opts[:shell].eql? :powershell
+      def execute(command, opts={}, &block)
+        if opts[:shell].eql? :cmd
+          session.cmd(command, &block)[:exitcode]
+        else
           command = VagrantWindows.load_script("command_alias.ps1") << "\r\n" << command
+          session.powershell(command, &block)[:exitcode]
         end
-        exit_status = 0
-        
-        begin
-          # Connect via WinRM and execute the command in the shell.
-          exceptions = [HTTPClient::KeepAliveDisconnected] 
-          exit_status = retryable(:tries => @machine.config.winrm.max_tries, :on => exceptions, :sleep => 10) do
-            shell_execute(command, opts[:shell], &block)
-          end
-        rescue StandardError => e
-          # return a more specific auth error for 401 errors
-          if e.message.include?("401")
-            raise Errors::WinRMAuthorizationError,
-              :user => @machine.config.winrm.username,
-              :password => @machine.config.winrm.password,
-              :endpoint => endpoint,
-              :message => e.message 
-          end
-          # failed for an unknown reason, didn't even get an exit status
-          raise Errors::WinRMExecutionError,
-            :shell => opts[:shell],
-            :command => command,
-            :message => e.message
-        end
-
-        # Check for any exit status errors
-        if opts[:error_check] && exit_status != 0
-          error_opts = opts.merge(:_key => opts[:error_key], :exit_status => exit_status)
-          raise error_opts[:error_class], error_opts 
-        end
-
-        exit_status
-      end
-      
-      # Wrap Sudo in execute.... One day we could integrate with UAC, but Icky
-      def sudo(command, opts=nil, &block)
-        execute(command, opts, &block)
-      end
-      
-      def download(from, to=nil)
-        @logger.warn("Downloading: #{from} to #{to} not supported on Windows guests")
       end
+      alias_method :sudo, :execute
       
       def test(command, opts=nil)
-        opts = { :error_check => false }.merge(opts || {})
-        execute(command, opts) == 0
+        # HACK: to speed up Vagrant 1.2 OS detection, skip checking for *nix OS
+        return false unless (command =~ /^uname|^cat \/etc|^cat \/proc|grep 'Fedora/).nil?
+        execute(command) == 0
       end
-      
+
       def upload(from, to)
         @logger.debug("Uploading: #{from} to #{to}")
-        
         file = "winrm-upload-#{rand()}"
         file_name = (session.cmd("echo %TEMP%\\#{file}"))[:data][0][:stdout].chomp
         session.powershell <<-EOH
@@ -113,103 +68,53 @@ module VagrantWindows
           }
         EOH
         Base64.encode64(IO.binread(from)).gsub("\n",'').chars.to_a.each_slice(8000-file_name.size) do |chunk|
-          out = session.cmd( "echo #{chunk.join} >> \"#{file_name}\"" )
+          out = session.cmd("echo #{chunk.join} >> \"#{file_name}\"")
         end
-        execute "mkdir $([System.IO.Path]::GetDirectoryName(\"#{to}\"))"
-        execute <<-EOH
+        session.powershell("mkdir $([System.IO.Path]::GetDirectoryName(\"#{to}\"))")
+        session.powershell <<-EOH
           $base64_string = Get-Content \"#{file_name}\"
           $bytes  = [System.Convert]::FromBase64String($base64_string) 
           $new_file = [System.IO.Path]::GetFullPath(\"#{to}\")
           [System.IO.File]::WriteAllBytes($new_file,$bytes)
         EOH
       end
-
-      def new_session
-        opts = endpoint_options()
-        logger.debug("Creating WinRM session to #{endpoint} with options: #{opts}")
-
-        client = ::WinRM::WinRMWebService.new(endpoint, :plaintext, opts)
-        client.set_timeout(opts[:operation_timeout])
-        client.toggle_nori_type_casting(:off) #we don't want coersion of types
-        client
+      
+      def download(from, to=nil)
+        @logger.warn("Downloading: #{from} to #{to} not supported on Windows guests")
       end
-
-      def session
-        @session ||= new_session
+      
+      # Runs a remote WQL query against the VM
+      #
+      # Note: This is not part of the standard Vagrant communicator interface, but
+      # guest capabilities may need to use this.
+      def wql(query)
+        session.wql(query)
       end
-
-      protected
-
-      def endpoint_options
-        {
-          :user => @machine.config.winrm.username,
-          :pass => @machine.config.winrm.password,
-          :host => @machine.config.winrm.host,
-          :port => winrm_port(),
-          :operation_timeout => @machine.config.winrm.timeout,
-          :basic_auth_only => true
-        }.merge ({})
+      
+      def set_winrmshell(winrmshell)
+        @session = winrmshell
       end
       
-      def winrm_port
-        @winrm_port ||= find_winrm_host_port()
+      def session
+        @session ||= new_session
       end
+      alias_method :winrmshell, :session
       
-      def find_winrm_host_port
-        expected_guest_port = @machine.config.winrm.guest_port
-        @logger.debug("Searching for WinRM port: #{expected_guest_port.inspect}")
       
-        # Look for the forwarded port only by comparing the guest port
-        @machine.provider.driver.read_forwarded_ports.each do |_, _, hostport, guestport|
-          return hostport if guestport == expected_guest_port
-        end
-        
-        @machine.config.winrm.port
-      end
-
-      def endpoint
-        if !@winrm_endpoint
-          opts = endpoint_options()
-          @winrm_endpoint = "http://#{opts[:host]}:#{opts[:port]}/wsman"
-        end
-        @winrm_endpoint
-      end    
-
-      # Executes the command on an SSH connection within a login shell.
-      def shell_execute(command, shell=:powershell, &block)
-        @logger.debug("#{shell} executing:\n#{command}")
-        
-        if shell.eql? :cmd
-          output = session.cmd(command) do |out, err|
-            handle_out(:stdout, out, &block)
-            handle_out(:stderr, err, &block)
-          end
-        elsif shell.eql? :powershell
-          output = session.powershell(command) do |out, err|
-            handle_out(:stdout, out, &block)
-            handle_out(:stderr, err, &block)
-          end
-        else
-          raise Errors::WinRMInvalidShell, :shell => shell
-        end
-
-        exit_status = output[:exitcode]
-        @logger.debug("Exit status: #{exit_status.inspect}")
-
-        # Return the final exit status
-        return exit_status
-      end
+      protected
       
-      def handle_out(type, data, &block)
-        if block_given? && data
-          if data =~ /\n/
-            data.split(/\n/).each { |d| block.call(type, d) }
-          else
-            block.call(type, data)
-          end
-        end
+      def new_session
+        WinRMShell.new(
+          @winrm_finder.winrm_host_address(),
+          @machine.config.winrm.username,
+          @machine.config.winrm.password,
+          {
+            :port => @winrm_finder.winrm_host_port(),
+            :timeout_in_seconds => @machine.config.winrm.timeout,
+            :max_tries => @machine.config.winrm.max_tries
+          })
       end
-
+      
     end #WinRM class
   end
 end