vagrant-plugin-dummy 0.0.1

data/windows/communication/winrmcommunicator.rb

@@ -0,0 +1,120 @@
+require 'timeout'
+require 'log4r'
+require_relative '../errors'
+require_relative 'winrmshell'
+require_relative 'winrmfinder'
+
+module VagrantWindows
+  module Communication
+    # Provides communication with the VM via WinRM.
+    class WinRMCommunicator < Vagrant.plugin("2", :communicator)
+
+      attr_reader :logger
+      attr_reader :machine
+      attr_reader :winrm_finder
+      
+      def self.match?(machine)
+        machine.config.vm.guest.eql? :windows
+      end
+
+      def initialize(machine)
+        @machine = machine
+        @logger = Log4r::Logger.new("vagrant_windows::communication::winrmcommunicator")
+        @logger.debug("initializing WinRMCommunicator")
+        @winrm_finder = WinRMFinder.new(machine)
+      end
+
+      def ready?
+        logger.debug("Checking whether WinRM is ready...")
+
+        Timeout.timeout(@machine.config.winrm.timeout) do
+          session.powershell("hostname")
+        end
+
+        logger.info("WinRM is ready!")
+        return true
+        
+      rescue Vagrant::Errors::VagrantError => e
+        # We catch a `VagrantError` which would signal that something went
+        # wrong expectedly in the `connect`, which means we didn't connect.
+        @logger.info("WinRM not up: #{e.inspect}")
+        return false
+      end
+      
+      def execute(command, opts={}, &block)
+        if opts[:shell].eql? :cmd
+          session.cmd(command, &block)[:exitcode]
+        else
+          command = VagrantWindows.load_script("command_alias.ps1") << "\r\n" << command
+          session.powershell(command, &block)[:exitcode]
+        end
+      end
+      alias_method :sudo, :execute
+      
+      def test(command, opts=nil)
+        # HACK: to speed up Vagrant 1.2 OS detection, skip checking for *nix OS
+        return false unless (command =~ /^uname|^cat \/etc|^cat \/proc|grep 'Fedora/).nil?
+        execute(command) == 0
+      end
+
+      def upload(from, to)
+        @logger.debug("Uploading: #{from} to #{to}")
+        file = "winrm-upload-#{rand()}"
+        file_name = (session.cmd("echo %TEMP%\\#{file}"))[:data][0][:stdout].chomp
+        session.powershell <<-EOH
+          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
+        session.powershell("mkdir $([System.IO.Path]::GetDirectoryName(\"#{to}\"))")
+        session.powershell <<-EOH
+          $base64_string = Get-Content \"#{file_name}\"
+          $bytes  = [System.Convert]::FromBase64String($base64_string) 
+          $new_file = [System.IO.Path]::GetFullPath(\"#{to}\")
+          [System.IO.File]::WriteAllBytes($new_file,$bytes)
+        EOH
+      end
+      
+      def download(from, to=nil)
+        @logger.warn("Downloading: #{from} to #{to} not supported on Windows guests")
+      end
+      
+      # Runs a remote WQL query against the VM
+      #
+      # Note: This is not part of the standard Vagrant communicator interface, but
+      # guest capabilities may need to use this.
+      def wql(query)
+        session.wql(query)
+      end
+      
+      def set_winrmshell(winrmshell)
+        @session = winrmshell
+      end
+      
+      def session
+        @session ||= new_session
+      end
+      alias_method :winrmshell, :session
+      
+      
+      protected
+      
+      def new_session
+        WinRMShell.new(
+          @winrm_finder.winrm_host_address(),
+          @machine.config.winrm.username,
+          @machine.config.winrm.password,
+          {
+            :port => @winrm_finder.winrm_host_port(),
+            :timeout_in_seconds => @machine.config.winrm.timeout,
+            :max_tries => @machine.config.winrm.max_tries
+          })
+      end
+      
+    end #WinRM class
+  end
+end

data/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/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/windows/config/windows.rb

@@ -0,0 +1,35 @@
+require "vagrant"
+
+module VagrantWindows
+  module Config
+    class Windows < Vagrant.plugin("2", :config)
+
+      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)
+        errors = []
+
+        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
+  end
+end

data/windows/config/winrm.rb

@@ -0,0 +1,51 @@
+require "vagrant"
+
+module VagrantWindows
+  module Config
+    class WinRM < Vagrant.plugin("2", :config)
+
+      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   = UNSET_VALUE
+        @password   = UNSET_VALUE
+        @host       = UNSET_VALUE
+        @port       = UNSET_VALUE
+        @guest_port = UNSET_VALUE
+        @max_tries  = UNSET_VALUE
+        @timeout    = UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+
+        errors << "winrm.username cannot be nil."   if machine.config.winrm.username.nil?
+        errors << "winrm.password cannot be nil."   if machine.config.winrm.password.nil?
+        errors << "winrm.host cannot be nil."       if machine.config.winrm.host.nil?
+        errors << "winrm.port cannot be nil."       if machine.config.winrm.port.nil?
+        errors << "winrm.guest_port cannot be nil." if machine.config.winrm.guest_port.nil?
+        errors << "winrm.max_tries cannot be nil."  if machine.config.winrm.max_tries.nil?
+        errors << "winrm.timeout cannot be nil."    if machine.config.winrm.timeout.nil?
+
+        { "WinRM" => errors }
+      end
+
+      def finalize!
+        @username = "vagrant" if @username == UNSET_VALUE
+        @password = "vagrant" if @password == UNSET_VALUE
+        @host = "localhost"   if @host == UNSET_VALUE
+        @port = 5985          if @port == UNSET_VALUE
+        @guest_port = 5985    if @guest_port == UNSET_VALUE
+        @max_tries = 20       if @max_tries == UNSET_VALUE
+        @timeout = 1800       if @timeout == UNSET_VALUE
+      end
+
+    end
+  end
+end

data/windows/errors.rb

@@ -0,0 +1,27 @@
+require 'vagrant/errors'
+
+module VagrantWindows
+  module Errors
+    
+    class VagrantWindowsError < ::Vagrant::Errors::VagrantError
+      error_namespace("vagrant_windows.errors")
+    end  
+    
+    class WinRMPortNotDetected < VagrantWindowsError
+      error_key(:winrm_port_not_detected)
+    end
+
+    class WinRMInvalidShell < VagrantWindowsError
+      error_key(:winrm_invalid_shell)
+    end
+    
+    class WinRMExecutionError < VagrantWindowsError
+      error_key(:winrm_execution_error)
+    end
+    
+    class WinRMAuthorizationError < VagrantWindowsError
+      error_key(:winrm_auth_error)
+    end    
+
+  end
+end

data/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/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/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/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/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/windows/guest/windows.rb

@@ -0,0 +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
+    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 = nil)
+        super(machine) unless machine == nil
+        @machine = machine
+      end
+      
+      def change_host_name(name)
+        VagrantWindows::Guest::Cap::ChangeHostName.change_host_name(@machine, name)
+      end
+      
+      def distro_dispatch
+        :windows
+      end
+      
+      def halt
+        VagrantWindows::Guest::Cap::Halt.halt(@machine)
+      end
+      
+      def mount_virtualbox_shared_folder(name, guestpath, options)
+        VagrantWindows::Guest::Cap::MountVirtualBoxSharedFolder.mount_virtualbox_shared_folder(
+          @machine, name, guestpath, options)
+      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)
+        VagrantWindows::Guest::Cap::ConfigureNetworks.configure_networks(@machine, networks)
+      end
+      
+      
+      # Vagrant 1.2.x compatibibility methods
+      
+      def detect?(machine)
+        
+        # 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

data/windows/helper.rb

@@ -0,0 +1,19 @@
+module VagrantWindows
+  module Helper
+    extend self
+    
+    def win_friendly_path(path)
+      if path
+        new_path = path.gsub('/', '\\')
+        new_path = "c:#{new_path}" if new_path =~ /^\\/
+      end
+      new_path
+    end
+
+    # turns '/vagrant' into 'vagrant' or turns ''/a/b/c/d/e' into 'a_b_c_d_e'
+    def win_friendly_share_id(shared_folder_name)
+      return shared_folder_name.gsub(/[\/\/]/,'_').sub(/^_/, '')
+    end
+    
+  end
+end

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

@@ -0,0 +1,32 @@
+require_relative '../../../helper'
+require_relative '../../../communication/winrmcommunicator'
+
+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
+
+    def is_windows?
+      return @config.vm.guest.eql? :windows
+    end
+    
+  end
+end