vagrant-windows 0.1.2 → 1.0.0

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

@@ -1,45 +1,52 @@
-module Vagrant
+module VagrantWindows
   module Guest
     # A general Vagrant system implementation for "windows".
     #
     # Contributed by Chris McClimans <chris@hippiehacker.org>
-    class Windows < Base
-      # A custom config class which will be made accessible via `config.windows`
-      # Here for whenever it may be used.
-      class WindowsError < Errors::VagrantError
-        error_namespace("vagrant.guest.windows")
+    class Windows < Vagrant.plugin("2", :guest)
+      
+      attr_reader :machine
+      
+      def initialize(machine)
+        super(machine)
+        @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
-        vm.channel.execute("wmic computersystem where name=\"%COMPUTERNAME%\" call rename name=\"#{name}\"")
+        @machine.communicate.execute(
+          "wmic computersystem where name=\"%COMPUTERNAME%\" call rename name=\"#{name}\"",
+          :shell => :cmd)
       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
-        @vm.channel.execute("shutdown /s /t 1 /c \"Vagrant Halt\" /f /d p:4:1")
+        @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 @vm.state != :poweroff
+        while @machine.state != :poweroff
           count += 1
 
-          return if count >= @vm.config.windows.halt_timeout
-          sleep @vm.config.windows.halt_check_interval
+          return if count >= @machine.config.windows.halt_timeout
+          sleep @machine.config.windows.halt_check_interval
         end
       end
 
       def mount_shared_folder(name, guestpath, options)
-        mount_script = TemplateRenderer.render(File.expand_path("#{File.dirname(__FILE__)}/../scripts/mount_volume.ps1"),
-                                          :options => {:mount_point => guestpath, :name => name})
-
-        @vm.channel.execute(mount_script,{:shell => :powershell})
+        @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})
       end
 
       def mount_nfs(ip, folders)
@@ -51,54 +58,52 @@ module Vagrant
         #  real_guestpath = expanded_guest_path(opts[:guestpath])
 
           # Do the actual creating and mounting
-        #  @vm.channel.sudo("mkdir -p #{real_guestpath}")
-        #  @vm.channel.sudo("mount -o vers=#{opts[:nfs_version]} #{ip}:'#{opts[:hostpath]}' #{real_guestpath}",
+        #  @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
       end
 
       def configure_networks(networks)
-        ### HACK!!!!! 
-        Nori.advanced_typecasting = false
-        if driver_mac_address = @vm.driver.read_mac_addresses
-          driver_mac_address = driver_mac_address.invert
+        @logger.info("configure_networks: #{networks.inspect}")
+
+        # The VBox driver 4.0 and 4.1 implement read_mac_addresses, but 4.2 does not?
+        begin
+          driver_mac_address = @machine.provider.driver.read_mac_addresses.invert
+        rescue NoMethodError
+          driver_mac_address = {}
+          driver_mac_address[@machine.provider.driver.read_mac_address] = "macaddress1"
         end
 
         vm_interface_map = {}
-        @vm.channel.session.wql("SELECT * FROM Win32_NetworkAdapter WHERE NetConnectionStatus=2")[:win32_network_adapter].each do |nic|
+
+        # 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] }
+            vm_interface_map[driver_mac_address[naked_mac]] =
+              { :name => nic[:net_connection_id], :mac_address => naked_mac, :index => nic[:interface_index] }
           end
         end
+        
         networks.each do |network|
+          netsh = "netsh interface ip set address \"#{vm_interface_map[network[:interface]+1][:name]}\" "
           if network[:type].to_sym == :static
-              vm.channel.execute("netsh interface ip set address \"#{vm_interface_map[network[:interface]+1][:name]}\" static #{network[:ip]} #{network[:netmask]}")
+            netsh = "#{netsh} static #{network[:ip]} #{network[:netmask]}"
           elsif network[:type].to_sym == :dhcp
-            vm.channel.execute("netsh interface ip set address \"#{vm_interface_map[network[:interface]+1][:name]}\" 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
         
       end
 
-
-      def windows_path(path)
-        p = ''
-        if path =~ /^\//
-          p << 'C:\\'
-        end
-        p << path
-        p.gsub! /\//, "\\"
-        p.gsub /\\\\{0,}/, "\\"
-      end
-
-
-
     end
   end
 end
-
-Vagrant.guests.register(:windows)  { Vagrant::Guest::Windows }

data/lib/vagrant-windows/monkey_patches/chef_solo.rb

@@ -0,0 +1,61 @@
+require "#{VagrantWindows::vagrant_root}/plugins/provisioners/chef/provisioner/chef_solo"
+
+module VagrantPlugins
+  module Chef
+    module Provisioner
+      class ChefSolo < Base
+
+        run_chef_solo_on_linux = instance_method(:run_chef_solo)
+
+        # This patch is needed until Vagrant supports chef on Windows guests
+        define_method(:run_chef_solo) do
+          is_windows ? run_chef_solo_on_windows() : run_chef_solo_on_linux.bind(self).()
+        end
+        
+        def run_chef_solo_on_windows
+          command_env = @config.binary_env ? "#{@config.binary_env} " : ""
+          command_args = @config.arguments ? " #{@config.arguments}" : ""
+          command_solo = "#{command_env}#{chef_binary_path("chef-solo")} "
+          command_solo << "-c #{@config.provisioning_path}/solo.rb "
+          command_solo << "-j #{@config.provisioning_path}/dna.json "
+          command_solo << "#{command_args}"
+          
+          command = VagrantWindows.load_script_template("ps_runas.ps1",
+            :options => {
+              :user => machine.config.winrm.username, 
+              :password => @machine.config.winrm.password,
+              :cmd => "powershell.exe",
+              :arguments => "-Command #{command_solo}"})
+
+          @config.attempts.times do |attempt|
+            if attempt == 0
+              @machine.env.ui.info I18n.t("vagrant.provisioners.chef.running_solo")
+            else
+              @machine.env.ui.info I18n.t("vagrant.provisioners.chef.running_solo_again")
+            end
+
+            exit_status = @machine.communicate.sudo(command, :error_check => false) do |type, data|
+              # Output the data with the proper color based on the stream.
+              color = type == :stdout ? :green : :red
+
+              # Note: Be sure to chomp the data to avoid the newlines that the
+              # Chef outputs.
+              @machine.env.ui.info(data.chomp, :color => color, :prefix => false)
+            end
+
+            # There is no need to run Chef again if it converges
+            return if exit_status == 0
+          end
+
+          # If we reached this point then Chef never converged! Error.
+          raise ChefError, :no_convergence
+        end
+        
+        def is_windows
+          @machine.config.vm.guest.eql? :windows
+        end
+        
+      end # ChefSolo class
+    end
+  end
+end

data/lib/vagrant-windows/monkey_patches/machine.rb

@@ -0,0 +1,25 @@
+module Vagrant
+  class Machine
+    
+    ssh_communicate = instance_method(:communicate)
+    
+    # This patch is needed until Vagrant supports a configurable communication channel
+    define_method(:communicate) do
+      unless @communicator
+        if @config.vm.guest.eql? :windows
+          @logger.info("guest is #{@config.vm.guest}, using WinRM for communication channel")
+          @communicator = ::VagrantWindows::Communication::WinRMCommunicator.new(self)
+        else
+          @logger.info("guest is #{@config.vm.guest}, using SSH for communication channel")
+          @communicator = ssh_communicate.bind(self).()
+        end
+      end
+      @communicator
+    end
+    
+    def winrm
+      @winrm ||= WinRM.new(self)
+    end
+
+  end
+end

data/lib/vagrant-windows/monkey_patches/puppet.rb

@@ -0,0 +1,100 @@
+require "#{VagrantWindows::vagrant_root}/plugins/provisioners/puppet/provisioner/puppet"
+
+module VagrantPlugins
+  module Puppet
+    module Provisioner
+      class Puppet < Vagrant.plugin("2", :provisioner)
+        
+        # This patch is needed until Vagrant supports Puppet on Windows guests
+        run_puppet_apply_on_linux = instance_method(:run_puppet_apply)
+        configure_on_linux = instance_method(:configure)
+        
+        define_method(:run_puppet_apply) do
+          is_windows ? run_puppet_apply_on_windows() : run_puppet_apply_on_linux.bind(self).()
+        end
+        
+        define_method(:configure) do |root_config|
+          is_windows ? configure_on_windows(root_config) : configure_on_linux.bind(self).(root_config)
+        end
+        
+        def run_puppet_apply_on_windows
+          options = [config.options].flatten
+          module_paths = @module_paths.map { |_, to| to }
+          if !@module_paths.empty?
+            # Prepend the default module path
+            module_paths.unshift("/etc/puppet/modules")
+
+            # Add the command line switch to add the module path
+            options << "--modulepath '#{module_paths.join(';')}'"
+          end
+
+          options << @manifest_file
+          options = options.join(" ")
+
+          # Build up the custom facts if we have any
+          facter = ""
+          if !config.facter.empty?
+            facts = []
+            config.facter.each do |key, value|
+              facts << "$env:FACTER_#{key}='#{value}';"
+            end
+
+            facter = "#{facts.join(" ")} "
+          end
+          
+          command = "cd #{manifests_guest_path}; if($?) \{ #{facter} puppet apply #{options} \}"
+          
+          @machine.env.ui.info I18n.t("vagrant.provisioners.puppet.running_puppet",
+                                      :manifest => @manifest_file)
+
+          @machine.communicate.sudo(command) do |type, data|
+            data.chomp!
+            @machine.env.ui.info(data, :prefix => false) if !data.empty?
+          end
+        end
+        
+        def configure_on_windows(root_config)
+          # Calculate the paths we're going to use based on the environment
+          root_path = @machine.env.root_path
+          @expanded_manifests_path = @config.expanded_manifests_path(root_path)
+          @expanded_module_paths   = @config.expanded_module_paths(root_path)
+          @manifest_file           = @config.manifest_file
+
+          # Setup the module paths
+          @module_paths = []
+          @expanded_module_paths.each_with_index do |path, i|
+            @module_paths << [path, File.join(config.pp_path, "modules-#{i}")]
+          end
+
+          @logger.debug("Syncing folders from puppet configure")
+          @logger.debug("manifests_guest_path = #{manifests_guest_path}")
+          @logger.debug("expanded_manifests_path = #{@expanded_manifests_path}")
+          
+          # Windows guest volume mounting fails without an "id" specified
+          # This hacks around that problem and allows the PS mount script to work
+          root_config.vm.synced_folder(
+            @expanded_manifests_path, manifests_guest_path,
+            :id =>  "v-manifests-1")
+
+          # Share the manifests directory with the guest
+          #root_config.vm.synced_folder(
+          #  @expanded_manifests_path, manifests_guest_path)
+
+          # Share the module paths
+          count = 0
+          @module_paths.each do |from, to|
+            # Sorry for the cryptic key here, but VirtualBox has a strange limit on
+            # maximum size for it and its something small (around 10)
+            root_config.vm.synced_folder(from, to)
+            count += 1
+          end
+        end
+
+        def is_windows
+          @machine.config.vm.guest.eql? :windows
+        end
+
+      end # Puppet class
+    end
+  end
+end

data/lib/vagrant-windows/plugin.rb

@@ -0,0 +1,96 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant Windows plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.1.0"
+  raise "The Vagrant Windows plugin is only compatible with Vagrant 1.1+"
+end
+
+# Add vagrant-windows plugin errors
+require "vagrant-windows/errors"
+
+# Add Vagrant WinRM communication channel
+require "vagrant-windows/communication/winrmcommunicator"
+
+# Monkey Patch the VM object to support multiple channels, i.e. WinRM
+require "vagrant-windows/monkey_patches/machine"
+
+# Monkey patch the Puppet provisioner to support PowerShell/Windows
+require "vagrant-windows/monkey_patches/puppet"
+
+# Monkey patch the Chef-Solo provisioner to support PowerShell/Windows
+require "vagrant-windows/monkey_patches/chef_solo"
+
+# Add our windows specific config object
+require "vagrant-windows/config/windows"
+
+# Add our winrm specific config object
+require "vagrant-windows/config/winrm"
+
+# Add the new Vagrant Windows guest
+require "vagrant-windows/guest/windows"
+
+module VagrantWindows
+  class Plugin < Vagrant.plugin("2")
+    name "Windows guest"
+    description <<-DESC
+    This plugin installs a provider that allows Vagrant to manage
+    Windows machines as guests.
+    DESC
+    
+    guest(:windows) do
+      VagrantWindows::Guest::Windows
+    end
+    
+    config(:windows) do
+      VagrantWindows::Config::Windows
+    end
+      
+    config(:winrm) do
+      VagrantWindows::Config::WinRM
+    end
+    
+    # This initializes the internationalization strings.
+    def self.setup_i18n
+      I18n.load_path << File.expand_path("locales/en.yml", VagrantWindows.vagrant_windows_root)
+      I18n.reload!
+    end
+    
+    # This sets up our log level to be whatever VAGRANT_LOG is.
+    def self.setup_logging
+      require "log4r"
+
+      level = nil
+      begin
+        level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+      rescue NameError
+        # This means that the logging constant wasn't found,
+        # which is fine. We just keep `level` as `nil`. But
+        # we tell the user.
+        level = nil
+      end
+
+      # Some constants, such as "true" resolve to booleans, so the
+      # above error checking doesn't catch it. This will check to make
+      # sure that the log level is an integer, as Log4r requires.
+      level = nil if !level.is_a?(Integer)
+
+      # Set the logging level on all "vagrant" namespaced
+      # logs as long as we have a valid level.
+      if level
+        logger = Log4r::Logger.new("vagrant_windows")
+        logger.outputters = Log4r::Outputter.stderr
+        logger.level = level
+        logger = nil
+      end
+    end
+
+  end
+end
+
+VagrantWindows::Plugin.setup_logging()
+VagrantWindows::Plugin.setup_i18n()

data/lib/vagrant-windows/scripts/command_alias.ps1

@@ -1,10 +1,19 @@
 function which {
-    $command = [Array](Get-Command $args[0] -errorAction continue)
-    write-host  $command[0].Definition
+    $command = [Array](Get-Command $args[0] -errorAction SilentlyContinue)
+    if($null -eq $command)
+    {
+      exit 1
+    }
+    write-host $command[0].Definition
+    exit 0
 }
 
 function test ([Switch] $d, [String] $path) {
-  Resolve-Path $path| Out-Null;
+  if(Test-Path $path)
+  {
+    exit 0
+  }
+  exit 1
 }
 
 function chown {
@@ -17,7 +26,7 @@ function mkdir ([Switch] $p, [String] $path)
   {
     exit 0
   } else {
-    New-Item $p -Type Directory -Force | Out-Null
+    New-Item $path -Type Directory -Force | Out-Null
   }
 }
 

data/lib/vagrant-windows/scripts/ps_runas.ps1.erb

@@ -0,0 +1,56 @@
+function ps-runas ([String] $user, [String] $password, [String] $cmd, [String] $arguments)
+{
+  $secpasswd = ConvertTo-SecureString $password -AsPlainText -Force
+  $process = New-Object System.Diagnostics.Process
+  $setup = $process.StartInfo
+  $setup.FileName = $cmd
+  $setup.Arguments = $arguments
+  $setup.UserName = $user
+  $setup.Password = $secpasswd
+  $setup.Verb = "runas"
+  $setup.UseShellExecute = $false
+  $setup.RedirectStandardError = $true
+  $setup.RedirectStandardOutput = $true
+  $setup.RedirectStandardInput = $false
+  
+  $errEvent = Register-ObjectEvent -InputObj $process `
+    -Event "ErrorDataReceived" `
+    -Action `
+    {
+      param([System.Object] $sender, [System.Diagnostics.DataReceivedEventArgs] $e)
+      if ($e.Data)
+      {
+        Write-Host $e.Data
+      }
+      else
+      {
+        New-Event -SourceIdentifier "LastMsgReceived"
+      }
+    }
+
+  $outEvent = Register-ObjectEvent -InputObj $process `
+    -Event "OutputDataReceived" `
+    -Action `
+    {
+      param([System.Object] $sender, [System.Diagnostics.DataReceivedEventArgs] $e)
+      Write-Host $e.Data
+    }
+  
+  $exitCode = -1
+  if ($process.Start())
+  {
+    $process.BeginOutputReadLine()
+    $process.BeginErrorReadLine()
+  
+    $process.WaitForExit()
+    $exitCode = [int]$process.ExitCode
+    Wait-Event -SourceIdentifier "LastMsgReceived" -Timeout 60 | Out-Null
+  
+    $process.CancelOutputRead()
+    $process.CancelErrorRead()
+    $process.Close()
+  }
+  return $exitCode
+}
+
+exit ps-runas "<%= options[:user] %>" "<%= options[:password] %>" "<%= options[:cmd] %>" "<%= options[:arguments] %>"

data/lib/vagrant-windows/version.rb

@@ -1,3 +1,3 @@
 module VagrantWindows
-  VERSION = "0.1.2"
+  VERSION = "1.0.0"
 end

data/lib/vagrant-windows.rb

@@ -0,0 +1,33 @@
+require "pathname"
+
+module VagrantWindows
+  
+  def self.vagrant_lib_root
+    # example match: /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.2/lib
+    @vagrant_lib_root ||= $LOAD_PATH.select { |p| p =~ /\/vagrant-[1-9].[0-9].[0-9]\/lib/ }.first
+  end
+  
+  def self.vagrant_root
+    @vagrant_root ||= Pathname.new(File.expand_path("../", vagrant_lib_root))
+  end
+  
+  def self.vagrant_windows_root
+    @vagrant_windows_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+  end
+  
+  def self.load_script(script_file_name)
+    File.read(expand_script_path(script_file_name))
+  end
+  
+  def self.load_script_template(script_file_name, options)
+    Vagrant::Util::TemplateRenderer.render(expand_script_path(script_file_name), options)
+  end
+  
+  def self.expand_script_path(script_file_name)
+    File.expand_path("lib/vagrant-windows/scripts/#{script_file_name}", VagrantWindows.vagrant_windows_root)
+  end
+
+  
+end
+
+require "vagrant-windows/plugin"

data/locales/en.yml

@@ -0,0 +1,29 @@
+en:
+  vagrant_windows:
+
+    errors:
+      winrm_port_not_detected: |-
+        Vagrant could not detect the WinRM port.
+
+        Host port: %{port}
+        Guest port: %{guest_port}
+      winrm_invalid_shell: |-
+        %{shell} is not a supported type of Windows shell.
+      winrm_execution_error: |-
+        An error occurred executing a remote WinRM command.
+
+        Shell: %{shell}
+        Command: %{command}
+        Message: %{message}
+      winrm_bad_exit_status: |-
+        The remote command returned a bad exit status of %{exit_status}.
+
+        Shell: %{shell}
+        Command: %{command}
+      winrm_auth_error: |-
+        An authorization error occurred connecting to WinRM.
+
+        User: %{user}
+        Password: %{password}
+        Endpoint: %{endpoint}
+        Message: %{message}

data/vagrant-windows.gemspec

@@ -16,6 +16,5 @@ Gem::Specification.new do |gem|
   gem.version       = VagrantWindows::VERSION
 
   gem.add_runtime_dependency "winrm", "~> 1.1.1"
-  gem.add_runtime_dependency 'vagrant', "~> 1.0.3"
   gem.add_runtime_dependency 'highline'
 end