vagrant-windows 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.vagrant
+Vagrantfile

data/Gemfile

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

data/README.md

@@ -0,0 +1,78 @@
+ Building a Base Box
+ ===================
+ 
+ -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
+  - Disable Shutdown Tracker
+  
+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|
+
+  # 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
+
+What has not been tested
+========================
+- Everything Else!!!
+- Shell and Puppet Provisioners 
+  - Shell should work, though I have not vetted it yet.
+
+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.

data/Rakefile

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

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

@@ -0,0 +1,180 @@
+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 => 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],
+          :basic_auth_only => true
+        }.merge ({})
+
+        # create a session
+        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 = :cyan)
+        if data =~ /\n/
+          data.split(/\n/).each { |d| print_data(d, color) }
+        else
+          puts "#{h.color('winrm', color)} #{data.chomp}"
+        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) 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) 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
+      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 = 30
+      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,17 @@
+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
+  end
+end

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

@@ -0,0 +1,54 @@
+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.execute("wmic computersystem where name=\"%COMPUTERNAME%\" call rename name=\"#{name}\"")
+      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.
+        count = 0
+        while @vm.state != :poweroff
+          count += 1
+
+          return if count >= @vm.config.linux.halt_timeout
+          sleep @vm.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})
+      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/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/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,43 @@
+
+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] %>"
+
+Write-Host "Attempting to mount $ShareName to $MountPoint"
+if( (Test-Path "$MountPoint") -and (Test-ReparsePoint "$MountPoint") )
+{
+  Write-Host "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-Host "Mount point already exists and is not a symbolic link"
+  exit 1
+}
+
+$BaseDirectory = [System.IO.Path]::GetDirectoryName($MountPoint)
+
+if (-not (Test-Path $BaseDirectory))
+{
+  Write-Host "Creating parent directory for mount point"
+  mkdir $BaseDirectory
+}
+
+cmd /c mklink /D "$MountPoint" "\\vboxsrv\$ShareName"
+
+if ( $LASTEXITCODE -ne 0 )
+{
+  exit 1
+}

data/lib/vagrant-windows/version.rb

@@ -0,0 +1,3 @@
+module VagrantWindows
+  VERSION = "0.0.1"
+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,18 @@
+#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'
+
+#Monkey Patch the VM object to support multiple channels
+require 'vagrant-windows/monkey_patches/vm'
+
+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          = "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.3"
+  gem.add_runtime_dependency 'highline'
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-windows
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Paul Morton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-04 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.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+- !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
+- Gemfile
+- Gemfile.lock
+- 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/vm.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.24
+signing_key: 
+specification_version: 3
+summary: A small gem that adds windows guest support to vagrant, uses WinRM as the
+  Communication Channel
+test_files: []