realityforge-vagrant-windows 0.1.4

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+*.rbc
+Gemfile.lock
+pkg
+rdoc
+# IntelliJ project files
+/*.iml
+/*.ipr
+/*.iws

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p327

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org" 
+
+# Specify your gem's dependencies in my_gem.gemspec
+gemspec
+

data/README.md

@@ -0,0 +1,115 @@
+TODO:
+ vagrant rdp && vagrant ps to connect to VM
+
+ 
+Installing
+==========
+
+ ```
+ gem install vagrant-windows
+ ```
+
+Building a Base Box
+===================
+
+All Windows Machines
+-------------------- 
+ -Enable WinRM
+
+  ```
+   winrm quickconfig -q
+   winrm set winrm/config/winrs @{MaxMemoryPerShellMB="512"}
+   winrm set winrm/config @{MaxTimeoutms="1800000"}
+   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
+  
+Servers
+--------
+  - 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)
+  
+The Vagrant File
+================
+
+Add the following to your Vagrantfile
+
+```ruby
+  config.vm.guest = :windows
+
+  config.vm.forward_port 3389, 3390, :name => "rdp", :auto => true
+  config.vm.forward_port 5985, 5985, :name => "winrm", :auto => true
+```
+
+Example:
+```ruby
+Vagrant::Config.run do |config|
+
+  #The following timeout configuration is option, however if have
+  #any large remote_file resources in your chef recipes, you may
+  #experience timeouts (reported as 500 responses)
+  config.winrm.timeout = 1800     #Set WinRM Timeout in seconds (Default 30)
+
+  # Configure base box parameters
+  config.vm.box = "windows2008r2"
+  config.vm.box_url = "./windows-2008-r2.box"
+  config.vm.guest = :windows
+
+  config.vm.forward_port 3389, 3390, :name => "rdp", :auto => true
+  config.vm.forward_port 5985, 5985, :name => "winrm", :auto => true
+
+  config.vm.provision :chef_solo do |chef|
+    chef.add_recipe("your::recipe")
+  end
+
+end
+````
+
+What Works?
+===========
+- vagrant up|hault|reload|provision
+- Chef Vagrant Provisioner
+- Puppet standalone provisioning
+
+What has not been tested
+========================
+- Everything Else!!!
+- Shell provisioning
+  - Shell should work, though I have not vetted it yet.
+
+What does not work
+==================
+- <s>Complex networking setups</s> - Fixed in 0.0.3
+  - Note that I have not tested the Virtual Box 4.0 Driver, all _should_ work. Can someone please confirm?
+
+What Can I do to help?
+======================
+1. Contribute Code (See Below)
+2. Test Various Scenarios and file bugs for things that dont work
+
+Contributing
+============
+1. Fork it.
+2. Create a branch (git checkout -b my_feature_branch)
+3. Commit your changes (git commit -am "Added a sweet feature")
+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)
+
+
+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.
+
+
+Changelog
+=========
+0.1.1 - Remove extra debug information from command output.
+0.1.2 - added virtual box 4.2 support
+0.1.3 - added puppet provisioner

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

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

@@ -0,0 +1,185 @@
+require 'timeout'
+
+require 'log4r'
+#require 'em-winrm'
+require 'winrm'
+require 'highline'
+
+require 'vagrant/util/ansi_escape_code_remover'
+require 'vagrant/util/file_mode'
+require 'vagrant/util/platform'
+require 'vagrant/util/retryable'
+
+module Vagrant
+  module Communication
+    # Provides communication with the VM via WinRM.
+    class WinRM < Base
+
+      include Util::ANSIEscapeCodeRemover
+      include Util::Retryable
+
+      attr_reader :logger
+      attr_reader :vm
+
+      def initialize(vm)
+        @vm     = vm
+        @logger = Log4r::Logger.new("vagrant::communication::winrm")
+        @co = nil
+      end
+
+      def ready?
+        logger.debug("Checking whether WinRM is ready...")
+
+        Timeout.timeout(@vm.config.winrm.timeout) do
+          execute "hostname"
+        end
+
+        # If we reached this point then we successfully connected
+        logger.info("WinRM is ready!")
+        true
+      rescue Timeout::Error, HTTPClient::KeepAliveDisconnected => e
+        #, Errors::SSHConnectionRefused, Net::SSH::Disconnect => e
+        # The above errors represent various reasons that WinRM may not be
+        # ready yet. Return false.
+        logger.info("WinRM not up yet: #{e.inspect}")
+
+        return false
+      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 execute(command, opts=nil, &block)
+
+        # Connect to WinRM, giving it a few tries
+        logger.info("Connecting to WinRM: #{@vm.winrm.info[:host]}:#{@vm.winrm.info[:port]}")
+
+        opts = {
+          :error_check => true,
+          :error_class => Errors::VagrantError,
+          :error_key   => :winrm_bad_exit_status,
+          :command     => command,
+          :sudo        => false,
+          :shell      => :powershell
+        }.merge(opts || {})
+
+        # Connect via WinRM and execute the command in the shell.
+        exceptions = [HTTPClient::KeepAliveDisconnected] 
+        exit_status = retryable(:tries => @vm.config.winrm.max_tries,   :on => exceptions, :sleep => 10) do
+          logger.debug "WinRM Trying to connect"
+          shell_execute(command,opts[:shell], &block)
+        end
+
+        logger.debug("#{command} EXIT STATUS #{exit_status.inspect}")
+
+        # Check for any errors
+        if opts[:error_check] && exit_status != 0
+          # The error classes expect the translation key to be _key,
+          # but that makes for an ugly configuration parameter, so we
+          # set it here from `error_key`
+          error_opts = opts.merge(:_key => opts[:error_key])
+          raise opts[:error_class], error_opts
+        end
+
+        # Return the exit status
+        exit_status
+      end
+
+      def new_session
+        opts = {
+          :user => vm.config.winrm.username,
+          :pass => vm.config.winrm.password,
+          :host => vm.config.winrm.host,
+          :port => vm.winrm.info[:port],
+          :operation_timeout => vm.config.winrm.timeout,
+          :basic_auth_only => true
+        }.merge ({})
+
+        # create a session
+        logger.info("Attempting WinRM session with options: #{opts}")
+        begin
+          endpoint = "http://#{opts[:host]}:#{opts[:port]}/wsman"
+          client = ::WinRM::WinRMWebService.new(endpoint, :plaintext, opts)
+          client.set_timeout(opts[:operation_timeout]) if opts[:operation_timeout]
+        rescue ::WinRM::WinRMAuthorizationError => error
+          raise ::WinRM::WinRMAuthorizationError.new("#{error.message}@#{opts[:host]}")
+        end
+
+        client
+      end
+      
+      def session
+        @session ||= new_session
+      end
+      
+      def h
+        @highline ||= HighLine.new
+      end
+      
+      def print_data(data, color = :green)
+        if data =~ /\n/
+          data.split(/\n/).each { |d| print_data(d, color) }
+        else
+          puts h.color(data.chomp, color)
+        end
+      end
+
+      def upload(from, to)
+        file = "winrm-upload-#{rand()}"
+        file_name = (session.cmd("echo %TEMP%\\#{file}"))[:data][0][:stdout].chomp
+        session.powershell <<-EOH
+          if(Test-Path #{to})
+          {
+            rm #{to}
+          }
+        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}\"" )
+        end
+        execute "mkdir [System.IO.Path]::GetDirectoryName(\"#{to}\")"
+        execute <<-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
+
+      protected
+
+      # Executes the command on an SSH connection within a login shell.
+      def shell_execute(command,shell = :powershell)
+        logger.info("Execute: #{command}")
+        exit_status = nil
+
+        if shell.eql? :cmd
+          output = session.cmd(command) do |out,error|
+            print_data(out) if out
+            print_data(error, :red) if error
+          end  
+        elsif shell.eql? :powershell
+          new_command = File.read(File.expand_path("#{File.dirname(__FILE__)}/../scripts/command_alias.ps1"))
+          new_command << "\r\n"
+          new_command << command
+          output = session.powershell(new_command) do |out,error|
+            print_data(out) if out
+            print_data(error, :red) if error
+          end
+        else
+          raise Vagrant::Errors::WinRMInvalidShell, "#{shell} is not a valid type of shell"
+        end
+
+        
+        exit_status = output[:exitcode]
+        logger.debug exit_status.inspect
+
+        # Return the final exit status
+        return exit_status
+      rescue ::WinRM::WinRMHTTPTransportError => e
+          raise Vagrant::Errors::WinRMTimeout, e.message
+      end  
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Vagrant
+  module Config
+    class Windows < Vagrant::Config::Base
+      attr_accessor :winrm_user
+      attr_accessor :winrm_password
+      attr_accessor :halt_timeout
+      attr_accessor :halt_check_interval
+      attr_accessor :device
+      
+      def initialize
+        @winrm_user = 'vagrant'
+        @winrm_password = 'vagrant'
+        @halt_timeout = 30
+        @halt_check_interval = 1
+        @device = "e1000g"
+      end
+
+      def validate(env, errors)
+        [ :winrm_user, :winrm_password].each do |field|
+          errors.add(I18n.t("vagrant.config.common.error_empty", :field => field)) if !instance_variable_get("@#{field}".to_sym)
+        end
+      end
+    end
+  end
+end
+
+Vagrant.config_keys.register(:windows) { Vagrant::Config::Windows }

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

@@ -0,0 +1,31 @@
+module Vagrant
+  module Config
+    class WinRM < Vagrant::Config::Base
+      attr_accessor :username
+      attr_accessor :password
+      attr_accessor :host
+      attr_accessor :port
+      attr_accessor :guest_port
+      attr_accessor :max_tries
+      attr_accessor :timeout
+
+      def initialize
+        @username = "vagrant"
+        @password = "vagrant"
+        @guest_port = 5985
+        @host = "localhost"
+        @max_tries = 12
+        @timeout = 1800
+      end
+
+      def validate(env, errors)
+        [:username, :password, :host, :max_tries, :timeout].each do |field|
+          errors.add(I18n.t("vagrant.config.common.error_empty", :field => field)) if !instance_variable_get("@#{field}".to_sym)
+        end
+
+      end
+    end
+  end
+end
+
+Vagrant.config_keys.register(:winrm) { Vagrant::Config::WinRM }

data/lib/vagrant-windows/errors.rb

@@ -0,0 +1,22 @@
+module Vagrant
+  module Errors
+    class WinRMPortNotDetected < VagrantError
+      status_code(550)
+      error_key(:winrm_port_not_detected)
+    end
+
+    class WinRMInvalidShell < VagrantError
+      status_code(551)
+      error_key(:winrm_invalid_shell)
+    end
+    class WinRMTransferError < VagrantError
+      status_code(552)
+      error_key(:winrm_upload_error)
+    end
+    class WinRMTimeout < VagrantError
+      status_code(553)
+      error_key(:winrm_timeout)
+    end
+
+  end
+end

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

@@ -0,0 +1,116 @@
+module Vagrant
+  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")
+      end
+
+      def change_host_name(name)
+        #### on windows, renaming a computer seems to require a reboot
+        @vm.channel.session.cmd("netdom renamecomputer %COMPUTERNAME% /force /reb:2 /newname:#{name}")
+        sleep 5
+        wait_for_state :running, @vm.config.windows.halt_timeout, @vm.config.windows.halt_check_interval
+      end
+
+      # TODO: I am sure that ciphering windows versions will be important at some point
+      def distro_dispatch
+        :windows
+      end
+
+      def halt
+        @vm.channel.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.
+        wait_for_state :poweroff, @vm.config.windows.halt_timeout, @vm.config.windows.halt_check_interval
+      end
+
+      def wait_for_state(state, timeout, interval)
+        count = 0
+        while @vm.state != state
+          count += 1
+          return if count > timeout
+          sleep 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})
+      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
+        #  @vm.channel.sudo("mkdir -p #{real_guestpath}")
+        #  @vm.channel.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
+        end
+
+        vm_interface_map = {}
+        @vm.channel.session.wql("SELECT * FROM Win32_NetworkAdapter WHERE NetConnectionStatus=2")[: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
+        networks.each do |network|
+          interface_name = vm_interface_map[network[:interface]+1][:name]
+          interface_index = vm_interface_map[network[:interface]+1][:index]
+
+          if network[:type].to_sym == :static
+            @vm.channel.execute("netsh interface ip set address \"#{interface_name}\" static #{network[:ip]} #{network[:netmask]}")
+
+          elsif network[:type].to_sym == :dhcp
+
+            if !vm.channel.test("if (-not (netsh interface ip show address \"#{interface_name}\" | where \{$_ -match \"DHCP enabled:\s+Yes\"\})) \{exit 1\} ")
+              vm.channel.execute("netsh interface ip set address \"#{interface_name}\" dhcp")
+            end
+          end
+        end
+      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/driver.rb

@@ -0,0 +1,57 @@
+require 'vagrant/driver/virtualbox_base'
+require 'vagrant/driver/virtualbox'
+
+
+module Vagrant
+  module Driver
+
+    class VirtualBox_4_2 < VirtualBoxBase
+      def read_mac_addresses
+        macs = {}
+        info = execute("showvminfo", @uuid, "--machinereadable", :retryable => true)
+        info.split("\n").each do |line|
+          if matcher = /^macaddress(\d+)="(.+?)"$/.match(line)
+            adapter = matcher[1].to_i
+            mac = matcher[2].to_s
+            macs[adapter] = mac
+          end
+        end
+        macs
+      end
+    end
+
+    class VirtualBox_4_1 < VirtualBoxBase
+      def read_mac_addresses
+        macs = {}
+        info = execute("showvminfo", @uuid, "--machinereadable", :retryable => true)
+        info.split("\n").each do |line|
+          if matcher = /^macaddress(\d+)="(.+?)"$/.match(line)
+            adapter = matcher[1].to_i
+            mac = matcher[2].to_s
+            macs[adapter] = mac
+          end
+        end
+        macs
+      end
+    end
+
+    class VirtualBox_4_0 < VirtualBoxBase
+      def read_mac_addresses
+        macs = {}
+        info = execute("showvminfo", @uuid, "--machinereadable", :retryable => true)
+        info.split("\n").each do |line|
+          if matcher = /^macaddress(\d+)="(.+?)"$/.match(line)
+            adapter = matcher[1].to_i
+            mac = matcher[2].to_s
+            macs[adapter] = mac
+          end
+        end
+        macs
+      end
+    end
+
+    class VirtualBox < VirtualBoxBase
+      def_delegator :@driver, :read_mac_addresses
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Vagrant
+  class VM
+    def winrm
+      @winrm ||= WinRM.new(self)
+    end
+
+    def channel
+      if @guest.class.eql? Vagrant::Guest::Windows
+        @channel ||= Communication::WinRM.new(self)
+      else
+        @channel ||= Communication::SSH.new(self)
+      end
+      @channel 
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Vagrant
+  	module Provisioners
+    	class Puppet < Base
+    		def run_puppet_client
+		        options = [config.options].flatten
+		        if env[:vm].config.vm.guest == :windows
+		        	options << "--modulepath '#{@module_paths.values.join(';')}'" if !@module_paths.empty?
+		        else
+		        	options << "--modulepath '#{@module_paths.values.join(':')}'" if !@module_paths.empty?
+		        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|
+		          	if env[:vm].config.vm.guest == :windows
+		          		facts << "$env:FACTER_#{key}='#{value}';"
+					else
+		            	facts << "FACTER_#{key}='#{value}'"
+		            end
+		          end
+					
+		        	facter = "#{facts.join(" ")} "
+		        end
+		        if env[:vm].config.vm.guest == :windows
+		        	command = "cd #{manifests_guest_path}; if($?) \{ #{facter} puppet apply #{options} \}"
+		        else
+		        	command = "cd #{manifests_guest_path} && #{facter}puppet apply #{options}"
+		        end
+
+		        env[:ui].info I18n.t("vagrant.provisioners.puppet.running_puppet",
+		                             :manifest => @manifest_file)
+
+		        env[:vm].channel.sudo(command) do |type, data|
+		          env[:ui].info(data.chomp, :prefix => false)
+		        end
+	    	end
+			def verify_binary(binary)
+			  if env[:vm].config.vm.guest == :windows
+		      	command = "command #{binary}"
+		      else
+		      	command = "which #{binary}"
+		      end
+	          env[:vm].channel.sudo(command,
+	                              :error_class => PuppetError,
+	                              :error_key => :not_detected,
+	                              :binary => binary)
+	        end
+	        def verify_shared_folders(folders)
+		        folders.each do |folder|
+		          @logger.debug("Checking for shared folder: #{folder}")
+
+		          
+		          if env[:vm].config.vm.guest == :windows
+			       	if !env[:vm].channel.test("if(-not (test-path #{folder})) \{exit 1\} ")
+		            	raise PuppetError, :missing_shared_folders
+		          	end
+			      else
+			       	if !env[:vm].channel.test("test -d #{folder}")
+            			raise PuppetError, :missing_shared_folders
+         			end
+			      end
+
+		        end
+	      	end
+     	end
+  	end
+end

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

@@ -0,0 +1,35 @@
+require 'tempfile'
+
+module Vagrant
+  module Provisioners
+    class Winrm < Base
+      class Config < Vagrant::Config::Base
+        attr_accessor :inline
+
+        def validate(env, errors)
+          # Validate that the parameters are properly set
+          if !inline
+            errors.add("No inline set")
+          end
+        end
+      end
+
+      def self.config_class
+        Config
+      end
+
+      def provision!
+        env[:vm].channel.sudo(config.inline) do |type, data|
+          if [:stderr, :stdout].include?(type)
+            # 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.
+            env[:ui].info(data.chomp, :color => color, :prefix => false)
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,49 @@
+
+function Test-ReparsePoint([string]$path) {
+  $file = Get-Item $path -Force -ea 0
+  return [bool]($file.Attributes -band [IO.FileAttributes]::ReparsePoint)
+}
+
+
+$MountPoint = [System.IO.Path]::GetFullPath("<%= options[:mount_point] %>")
+$ShareName = "<%= options[:name] %>"
+
+# https://github.com/BIAINC/vagrant-windows/issues/4
+# Not sure why this works, but it does.
+
+& net use $ShareName 2>&1 | Out-Null
+
+Write-Debug "Attempting to mount $ShareName to $MountPoint"
+if( (Test-Path "$MountPoint") -and (Test-ReparsePoint "$MountPoint") )
+{
+  Write-Debug "Junction already exists, so I will delete it"
+  # Powershell refuses to delete junctions, oh well use cmd
+  cmd /c rd "$MountPoint"
+
+  if ( $LASTEXITCODE -ne 0 )
+  {
+    Write-Error "Failed to delete symbolic link at $MountPoint"
+    exit 1
+  }
+
+} 
+elseif(Test-Path $MountPoint) 
+{
+  Write-Debug "Mount point already exists and is not a symbolic link"
+  exit 1
+}
+
+$BaseDirectory = [System.IO.Path]::GetDirectoryName($MountPoint)
+
+if (-not (Test-Path $BaseDirectory))
+{
+  Write-Debug "Creating parent directory for mount point $BaseDirectory"
+  New-Item $BaseDirectory -Type Directory -Force | Out-Null
+}
+
+cmd /c mklink /D "$MountPoint" "\\vboxsrv\$ShareName" | out-null
+
+if ( $LASTEXITCODE -ne 0 )
+{
+  exit 1
+}

data/lib/vagrant-windows/version.rb

@@ -0,0 +1,3 @@
+module VagrantWindows
+  VERSION = "0.1.4"
+end

data/lib/vagrant-windows/winrm.rb

@@ -0,0 +1,82 @@
+require 'log4r'
+#require 'em-winrm'
+
+module Vagrant
+  # Manages WINRM access to a specific environment. Allows an environment to
+  # run commands, upload files, and check if a host is up.
+  class WinRM
+    include Util::SafeExec
+
+    def initialize(vm)
+      @vm = vm
+      @logger = Log4r::Logger.new("vagrant::winrm")
+    end
+
+    # Returns a hash of information necessary for accessing this
+    # virtual machine via WINRM.
+    #
+    # @return [Hash]
+    def info
+      results = {
+        :host          => @vm.config.winrm.host,
+        :port          => @vm.config.winrm.port || @vm.driver.ssh_port(@vm.config.winrm.guest_port),
+        :username      => @vm.config.winrm.username
+      }
+
+      # This can happen if no port is set and for some reason Vagrant
+      # can't detect an SSH port.
+      raise Errors::WinRMPortNotDetected if !results[:port]
+
+      # Return the results
+      return results
+    end
+
+    # Checks if this environment's machine is up (i.e. responding to WINRM).
+    #
+    # @return [Boolean]
+    def up?
+      # We have to determine the port outside of the block since it uses
+      # API calls which can only be used from the main thread in JRuby on
+      # Windows
+      ssh_port = port
+
+      require 'timeout'
+      Timeout.timeout(@env.config.ssh.timeout) do
+        execute 'hostname'
+      end
+
+      true
+    rescue Timeout::Error, Errno::ECONNREFUSED
+      return false
+    end
+
+    # Returns the port which is either given in the options hash or taken from
+    # the config by finding it in the forwarded ports hash based on the
+    # `config.ssh.forwarded_port_key`.
+    def port(opts={})
+      # Check if port was specified in options hash
+      return opts[:port] if opts[:port]
+
+      # Check if a port was specified in the config
+      return @env.config.winrm.port if @env.config.winrm.port
+
+      # Check if we have an SSH forwarded port
+      pnum_by_name = nil
+      pnum_by_destination = nil
+      @logger.info("Looking for winrm port: #{opts}")
+      @logger.info("Looking for winrm port: #{env.config.winrm.inspect}")
+
+      env.vm.vm.network_adapters.each do |na| 
+        # Look for the port number by destination...
+        pnum_by_destination = na.nat_driver.forwarded_ports.detect do |fp|
+          fp.guestport == env.config.winrm.guest_port
+        end
+      end
+
+      return pnum_by_destination.hostport if pnum_by_destination
+
+      # This should NEVER happen.
+      raise Errors::WinRMPortNotDetected
+    end
+  end
+end

data/lib/vagrant_init.rb

@@ -0,0 +1,24 @@
+#Add Windows Guest Defintion
+require 'vagrant-windows/guest/windows'
+
+#Add Configuration Items
+require 'vagrant-windows/config/windows'
+require 'vagrant-windows/config/winrm'
+
+# Add WinRM Communication Channel
+require 'vagrant-windows/communication/winrm'
+
+# Add Provisioner
+require 'vagrant-windows/provisioners/puppet'
+
+#Monkey Patch the VM object to support multiple channels
+require 'vagrant-windows/monkey_patches/vm'
+
+#Monkey Patch the driver to support returning a mapping of mac addresses to nics
+require 'vagrant-windows/monkey_patches/driver'
+
+require 'vagrant-windows/winrm'
+
+#Errors are good
+require 'vagrant-windows/errors'
+

data/vagrant-windows.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/vagrant-windows/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Paul Morton"]
+  gem.email         = ["pmorton@biaprotect.com"]
+  gem.description   = %q{Windows Guest Support for Vagrant}
+  gem.summary       = %q{A small gem that adds windows guest support to vagrant, uses WinRM as the Communication Channel}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "realityforge-vagrant-windows"
+  gem.require_paths = ["lib"]
+  gem.version       = VagrantWindows::VERSION
+
+  gem.add_runtime_dependency "winrm", "~> 1.1.1"
+  gem.add_runtime_dependency 'vagrant', "~> 1.0"
+  gem.add_runtime_dependency 'highline'
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: realityforge-vagrant-windows
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+  prerelease: 
+platform: ruby
+authors:
+- Paul Morton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: winrm
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+- !ruby/object:Gem::Dependency
+  name: vagrant
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Windows Guest Support for Vagrant
+email:
+- pmorton@biaprotect.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-version
+- Gemfile
+- README.md
+- Rakefile
+- lib/vagrant-windows/communication/winrm.rb
+- lib/vagrant-windows/config/windows.rb
+- lib/vagrant-windows/config/winrm.rb
+- lib/vagrant-windows/errors.rb
+- lib/vagrant-windows/guest/windows.rb
+- lib/vagrant-windows/monkey_patches/driver.rb
+- lib/vagrant-windows/monkey_patches/vm.rb
+- lib/vagrant-windows/provisioners/puppet.rb
+- lib/vagrant-windows/provisioners/winrm.rb
+- lib/vagrant-windows/scripts/command_alias.ps1
+- lib/vagrant-windows/scripts/mount_volume.ps1.erb
+- lib/vagrant-windows/version.rb
+- lib/vagrant-windows/winrm.rb
+- lib/vagrant_init.rb
+- vagrant-windows.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A small gem that adds windows guest support to vagrant, uses WinRM as the
+  Communication Channel
+test_files: []
+has_rdoc: