vagrant-windows 1.0.3 → 1.2.0

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

@@ -0,0 +1,45 @@
+require 'log4r'
+require_relative '../errors'
+
+module VagrantWindows
+  module Communication
+    class WinRMFinder
+
+      attr_reader :logger
+      attr_reader :machine
+    
+      def initialize(machine)
+        @machine = machine
+        @logger = Log4r::Logger.new("vagrant_windows::communication::winrmfinder")
+      end
+
+      def winrm_host_address
+        # Get the SSH info for the machine, raise an exception if the
+        # provider is saying that SSH is not ready.
+        ssh_info = @machine.ssh_info
+        raise Vagrant::Errors::SSHNotReady if ssh_info.nil?
+        @logger.info("WinRM host: #{ssh_info[:host]}")
+        return ssh_info[:host]
+      end
+      
+      def 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
+        begin
+          @machine.provider.driver.read_forwarded_ports.each do |_, _, hostport, guestport|
+            return hostport if guestport == expected_guest_port
+          end
+        rescue NoMethodError => e
+          # VMWare provider doesn't support read_forwarded_ports
+          @logger.debug(e.message)
+        end
+        
+        # We tried, give up and use the configured port as-is
+        @machine.config.winrm.port
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+require 'timeout'
+require 'log4r'
+require 'winrm'
+require 'vagrant/util/retryable'
+require_relative '../errors'
+
+module VagrantWindows
+  module Communication
+    class WinRMShell
+
+      include Vagrant::Util::Retryable
+      
+      # These are the exceptions that we retry because they represent
+      # errors that are generally fixed from a retry and don't
+      # necessarily represent immediate failure cases.
+      @@exceptions_to_retry_on = [
+        HTTPClient::KeepAliveDisconnected,
+        WinRM::WinRMHTTPTransportError,
+        Errno::EACCES,
+        Errno::EADDRINUSE,
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::ENETUNREACH,
+        Errno::EHOSTUNREACH,
+        Timeout::Error
+      ]
+
+      attr_reader :logger
+      attr_reader :username
+      attr_reader :password
+      attr_reader :host
+      attr_reader :port
+      attr_reader :timeout_in_seconds
+      attr_reader :max_tries
+
+      def initialize(host, username, password, options = {})
+        @logger = Log4r::Logger.new("vagrant_windows::communication::winrmshell")
+        @logger.debug("initializing WinRMShell")
+        
+        @host = host
+        @port = options[:port] || 5985
+        @username = username
+        @password = password
+        @timeout_in_seconds = options[:timeout_in_seconds] || 60
+        @max_tries = options[:max_tries] || 20
+      end
+      
+      def powershell(command, &block)
+        execute_shell(command, :powershell, &block)
+      end
+      
+      def cmd(command, &block)
+        execute_shell(command, :cmd, &block)
+      end
+      
+      def wql(query)
+        execute_wql(query)
+      end
+
+      protected
+      
+      def execute_shell(command, shell=:powershell, &block)
+        retryable(:tries => @max_tries, :on => @@exceptions_to_retry_on, :sleep => 10) do
+          @logger.debug("#{shell} executing:\n#{command}")
+          if shell.eql? :cmd
+            output = session.cmd(command) do |out, err|
+              block.call(:stdout, out) if block_given? && out
+              block.call(:stderr, err) if block_given? && err
+            end
+          elsif shell.eql? :powershell
+            output = session.powershell(command) do |out, err|
+              block.call(:stdout, out) if block_given? && out
+              block.call(:stderr, err) if block_given? && err
+            end
+          else
+            raise Errors::WinRMInvalidShell, :shell => shell
+          end
+          @logger.debug("Exit status: #{output[:exitcode].inspect}")
+          return output
+        end
+      rescue => e
+        handle_winrm_exception(e, shell, command)
+      end
+      
+      def execute_wql(query)
+        retryable(:tries => @max_tries, :on => @@exceptions_to_retry_on, :sleep => 10) do
+          @logger.debug("#executing wql: #{query}")
+          output = session.wql(query)
+          @logger.debug("wql result: #{output.inspect}")
+          return output
+        end
+      rescue => e
+        handle_winrm_exception(e, :wql, query)
+      end
+      
+      def handle_winrm_exception(winrm_exception, shell, command)
+        if winrm_exception.message.include?("401") # return a more specific auth error for 401 errors
+          raise Errors::WinRMAuthorizationError,
+            :user => @username,
+            :password => @password,
+            :endpoint => endpoint,
+            :message => winrm_exception.message
+        end
+        raise Errors::WinRMExecutionError,
+          :shell => shell,
+          :command => command,
+          :message => winrm_exception.message
+      end
+      
+      def new_session
+        @logger.info("Attempting to connect to WinRM...")
+        @logger.info("  - Host: #{@host}")
+        @logger.info("  - Port: #{@port}")
+        @logger.info("  - Username: #{@username}")
+        
+        client = ::WinRM::WinRMWebService.new(endpoint, :plaintext, endpoint_options)
+        client.set_timeout(@timeout_in_seconds)
+        client.toggle_nori_type_casting(:off) #we don't want coersion of types
+        client
+      end
+
+      def session
+        @session ||= new_session
+      end
+      
+      def endpoint
+        "http://#{@host}:#{@port}/wsman"
+      end
+
+      def endpoint_options
+        { :user => @username,
+          :pass => @password,
+          :host => @host,
+          :port => @port,
+          :operation_timeout => @timeout_in_seconds,
+          :basic_auth_only => true }
+      end
+      
+    end #WinShell class
+  end
+end

data/lib/vagrant-windows/config/windows.rb

@@ -6,10 +6,12 @@ module VagrantWindows
 
       attr_accessor :halt_timeout
       attr_accessor :halt_check_interval
+      attr_accessor :set_work_network
       
       def initialize
         @halt_timeout        = UNSET_VALUE
         @halt_check_interval = UNSET_VALUE
+        @set_work_network    = UNSET_VALUE
       end
 
       def validate(machine)
@@ -18,12 +20,14 @@ module VagrantWindows
         errors << "windows.halt_timeout cannot be nil."        if machine.config.windows.halt_timeout.nil?
         errors << "windows.halt_check_interval cannot be nil." if machine.config.windows.halt_check_interval.nil?
 
+        errors << "windows.set_work_network cannot be nil." if machine.config.windows.set_work_network.nil?
         { "Windows Guest" => errors }
       end
 
       def finalize!
         @halt_timeout = 30       if @halt_timeout == UNSET_VALUE
         @halt_check_interval = 1 if @halt_check_interval == UNSET_VALUE
+        @set_work_network = false if @set_work_network == UNSET_VALUE
       end
 
     end

data/lib/vagrant-windows/config/winrm.rb

@@ -42,7 +42,7 @@ module VagrantWindows
         @host = "localhost"   if @host == UNSET_VALUE
         @port = 5985          if @port == UNSET_VALUE
         @guest_port = 5985    if @guest_port == UNSET_VALUE
-        @max_tries = 12       if @max_tries == UNSET_VALUE
+        @max_tries = 20       if @max_tries == UNSET_VALUE
         @timeout = 1800       if @timeout == UNSET_VALUE
       end
 

data/lib/vagrant-windows/guest/cap/change_host_name.rb

@@ -0,0 +1,14 @@
+module VagrantWindows
+  module Guest
+    module Cap
+      class ChangeHostName
+        def self.change_host_name(machine, name)
+          #### on windows, renaming a computer seems to require a reboot
+          machine.communicate.execute(
+            "wmic computersystem where name=\"%COMPUTERNAME%\" call rename name=\"#{name}\"",
+            :shell => :cmd)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-windows/guest/cap/configure_networks.rb

@@ -0,0 +1,69 @@
+require 'log4r'
+require_relative '../../communication/guestnetwork'
+require_relative '../../communication/winrmshell'
+require_relative '../../errors'
+
+module VagrantWindows
+  module Guest
+    module Cap
+      class ConfigureNetworks
+        
+        @@logger = Log4r::Logger.new("vagrant_windows::guest::cap::configure_networks")
+        
+        def self.configure_networks(machine, networks)
+          @@logger.debug("networks: #{networks.inspect}")
+          
+          guest_network = ::VagrantWindows::Communication::GuestNetwork.new(machine.communicate.winrmshell)
+
+          if (machine.provider_name != :vmware_fusion) && (machine.provider_name != :vmware_workstation)
+            vm_interface_map = create_vm_interface_map(machine, guest_network)
+          end
+          
+          networks.each do |network|
+            interface = vm_interface_map[network[:interface]+1]
+            if interface.nil?
+              @@logger.warn("Could not find interface for network #{network.inspect}")
+              next
+            end
+            network_type = network[:type].to_sym
+            if network_type == :static
+              guest_network.configure_static_interface(
+                interface[:index],
+                interface[:net_connection_id],
+                network[:ip],
+                network[:netmask])
+            elsif network_type == :dhcp
+              guest_network.configure_dhcp_interface(
+                interface[:index],
+                interface[:net_connection_id])
+            else
+              raise WindowsError, "#{network_type} network type is not supported, try static or dhcp"
+            end
+          end
+          guest_network.set_all_networks_to_work() if machine.config.windows.set_work_network
+        end
+        
+        #{1=>{:name=>"Local Area Connection", :mac_address=>"0800275FAC5B", :interface_index=>"11", :index=>"7"}}
+        def self.create_vm_interface_map(machine, guest_network)
+          vm_interface_map = {}
+          driver_mac_address = machine.provider.driver.read_mac_addresses.invert
+          @@logger.debug("mac addresses: #{driver_mac_address.inspect}")
+          guest_network.network_adapters().each do |nic|
+            @@logger.debug("nic: #{nic.inspect}")
+            naked_mac = nic[:mac_address].gsub(':','')
+            if driver_mac_address[naked_mac]
+              vm_interface_map[driver_mac_address[naked_mac]] = {
+                :name => nic[:net_connection_id],
+                :mac_address => naked_mac,
+                :interface_index => nic[:interface_index],
+                :index => nic[:index] }
+            end
+          end
+          @@logger.debug("vm_interface_map: #{vm_interface_map.inspect}")
+          vm_interface_map
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-windows/guest/cap/halt.rb

@@ -0,0 +1,22 @@
+module VagrantWindows
+  module Guest
+    module Cap
+      class Halt
+        def self.halt(machine)
+          machine.communicate.execute("shutdown /s /t 1 /c \"Vagrant Halt\" /f /d p:4:1")
+
+          # Wait until the VM's state is actually powered off. If this doesn't
+          # occur within a reasonable amount of time (15 seconds by default),
+          # then simply return and allow Vagrant to kill the machine.
+          count = 0
+          while machine.state != :poweroff
+            count += 1
+
+            return if count >= machine.config.windows.halt_timeout
+            sleep machine.config.windows.halt_check_interval
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-windows/guest/cap/mount_virtualbox_shared_folder.rb

@@ -0,0 +1,17 @@
+require_relative '../../helper'
+
+module VagrantWindows
+  module Guest
+    module Cap
+      class MountVirtualBoxSharedFolder
+        
+        def self.mount_virtualbox_shared_folder(machine, name, guestpath, options)
+          share_name = VagrantWindows::Helper.win_friendly_share_id(name)
+          mount_script = VagrantWindows.load_script_template("mount_volume.virtualbox.ps1",
+            :options => {:mount_point => guestpath, :share_name => share_name})
+          machine.communicate.execute(mount_script, {:shell => :powershell})
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-windows/guest/cap/mount_vmware_shared_folder.rb

@@ -0,0 +1,15 @@
+module VagrantWindows
+  module Guest
+    module Cap
+      class MountVMwareSharedFolder
+
+        def self.mount_vmware_shared_folder(machine, name, guestpath, options)
+          share_name = VagrantWindows::Helper.win_friendly_share_id(name)
+          mount_script = VagrantWindows.load_script_template("mount_volume.vmware.ps1",
+            :options => {:mount_point => guestpath, :share_name => share_name})
+          machine.communicate.execute(mount_script, {:shell => :powershell})
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-windows/guest/windows.rb

@@ -1,102 +1,71 @@
+require "vagrant"
+require "vagrant-windows/guest/cap/change_host_name"
+require "vagrant-windows/guest/cap/configure_networks"
+require "vagrant-windows/guest/cap/halt"
+require "vagrant-windows/guest/cap/mount_virtualbox_shared_folder"
+require "vagrant-windows/guest/cap/mount_vmware_shared_folder"
+
 module VagrantWindows
   module Guest
-    # A general Vagrant system implementation for "windows".
-    #
-    # Contributed by Chris McClimans <chris@hippiehacker.org>
     class Windows < Vagrant.plugin("2", :guest)
       
+      # Vagrant 1.1.x compatibibility methods
+      # Implement the 1.1.x methods and call through to the new 1.2.x capabilities
+      
       attr_reader :machine
       
-      def initialize(machine)
-        super(machine)
+      def initialize(machine = nil)
+        super(machine) unless machine == nil
         @machine = machine
-        @logger = Log4r::Logger.new("vagrant_windows::guest::windows")
       end
-
+      
       def change_host_name(name)
-        @logger.info("change host name to: #{name}")
-        #### on windows, renaming a computer seems to require a reboot
-        @machine.communicate.execute(
-          "wmic computersystem where name=\"%COMPUTERNAME%\" call rename name=\"#{name}\"",
-          :shell => :cmd)
+        VagrantWindows::Guest::Cap::ChangeHostName.change_host_name(@machine, name)
       end
-
-      # TODO: I am sure that ciphering windows versions will be important at some point
+      
       def distro_dispatch
-        @logger.info("distro_dispatch: windows")
         :windows
       end
-
+      
       def halt
-        @machine.communicate.execute("shutdown /s /t 1 /c \"Vagrant Halt\" /f /d p:4:1")
-
-        # Wait until the VM's state is actually powered off. If this doesn't
-        # occur within a reasonable amount of time (15 seconds by default),
-        # then simply return and allow Vagrant to kill the machine.
-        count = 0
-        while @machine.state != :poweroff
-          count += 1
-
-          return if count >= @machine.config.windows.halt_timeout
-          sleep @machine.config.windows.halt_check_interval
-        end
+        VagrantWindows::Guest::Cap::Halt.halt(@machine)
       end
-
-      def mount_shared_folder(name, guestpath, options)
-        @logger.info("mount_shared_folder: #{name}")
-        mount_script = VagrantWindows.load_script_template("mount_volume.ps1",
-          :options => {:mount_point => guestpath, :name => name})
-        @machine.communicate.execute(mount_script, {:shell => :powershell})
+      
+      def mount_virtualbox_shared_folder(name, guestpath, options)
+        VagrantWindows::Guest::Cap::MountVirtualBoxSharedFolder.mount_virtualbox_shared_folder(
+          @machine, name, guestpath, options)
       end
 
-      def mount_nfs(ip, folders)
-        raise NotImplementedError, "Mounting NFS Shares on windows is not implemented"
-        # TODO: Maybe check for nfs support on the guest, since its often
-        # not installed by default
-        #folders.each do |name, opts|
-        #  # Expand the guestpath, so we can handle things like "~/vagrant"
-        #  real_guestpath = expanded_guest_path(opts[:guestpath])
-
-          # Do the actual creating and mounting
-        #  @machine.communicate.sudo("mkdir -p #{real_guestpath}")
-        #  @machine.communicate.sudo("mount -o vers=#{opts[:nfs_version]} #{ip}:'#{opts[:hostpath]}' #{real_guestpath}",
-        #                  :error_class => LinuxError,
-        #                  :error_key => :mount_nfs_fail)
-        #end
+      def mount_vmware_shared_folder(name, guestpath, options)
+        VagrantWindows::Guest::Cap::MountVMwareBoxSharedFolder.mount_vmware_shared_folder(
+            @machine, name, guestpath, options)
       end
-
+      
       def configure_networks(networks)
-        @logger.info("configure_networks: #{networks.inspect}")
-        driver_mac_address = @machine.provider.driver.read_mac_addresses.invert
-
-        vm_interface_map = {}
-
-        # NetConnectionStatus=2 -- connected
-        wql = "SELECT * FROM Win32_NetworkAdapter WHERE NetConnectionStatus=2"
-        @machine.communicate.session.wql(wql)[:win32_network_adapter].each do |nic|
-          naked_mac = nic[:mac_address].gsub(':','')
-          if driver_mac_address[naked_mac]
-            vm_interface_map[driver_mac_address[naked_mac]] =
-              { :name => nic[:net_connection_id], :mac_address => naked_mac, :index => nic[:interface_index] }
-          end
-        end
+        VagrantWindows::Guest::Cap::ConfigureNetworks.configure_networks(@machine, networks)
+      end
+      
+      
+      # Vagrant 1.2.x compatibibility methods
+      
+      def detect?(machine)
         
-        networks.each do |network|
-          netsh = "netsh interface ip set address \"#{vm_interface_map[network[:interface]+1][:name]}\" "
-          if network[:type].to_sym == :static
-            netsh = "#{netsh} static #{network[:ip]} #{network[:netmask]}"
-          elsif network[:type].to_sym == :dhcp
-            netsh = "#{netsh} dhcp"
-          else
-            raise WindowsError, "#{network[:type]} network type is not supported, try static or dhcp"
-          end
-          @machine.communicate.execute(netsh)
-        end
-
-        #netsh interface ip set address name="Local Area Connection" static 192.168.0.100 255.255.255.0 192.168.0.1 1
+        # uname -o | grep Solaris
+        # uname -s | grep 'Linux'
+        # uname -s | grep 'FreeBSD'
+        # cat /etc/redhat-release
+        # uname -s | grep 'OpenBSD'
+        # cat /etc/gentoo-release
+        # cat /proc/version | grep 'Debian'
+        # cat /etc/arch-release
+        # cat /proc/version | grep 'Ubuntu'
+        # cat /etc/SuSE-release
+        # cat /etc/pld-release
+        # grep 'Fedora release 1[678]' /etc/redhat-release
         
+        # see if the Windows directory is present
+        machine.communicate.test("test -d $Env:SystemRoot")
       end
-
     end
   end
 end