vagrant-plugin-dummy 0.0.1

data/windows/monkey_patches/plugins/providers/virtualbox/action/share_folders.rb

@@ -0,0 +1,44 @@
+require "#{Vagrant::source_root}/plugins/providers/virtualbox/action/share_folders"
+require_relative '../../../../../helper'
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class ShareFolders        
+        include VagrantWindows::Helper
+
+        alias_method :original_create_metadata, :create_metadata
+
+        def create_metadata
+
+          unless @env[:machine].is_windows?
+            # don't change the shared folder name for linux guests.  We don't want the shared folder name of linux guests to be different
+            # depending on whether the vagrant-windows plugin is installed or not.
+            original_create_metadata
+          else
+            @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.creating")
+
+            folders = []
+            shared_folders.each do |id, data|
+              hostpath = File.expand_path(data[:hostpath], @env[:root_path])
+              hostpath = Vagrant::Util::Platform.cygwin_windows_path(hostpath)
+
+              folder_name = win_friendly_share_id(id.gsub(/[\/\/]/,'_').sub(/^_/, ''))
+
+              folders << {
+                  :name => folder_name,
+                  :hostpath => hostpath,
+                  :transient => data[:transient]
+              }
+            end
+
+            @env[:machine].provider.driver.share_folders(folders)
+          end
+        end
+
+
+
+      end
+    end
+  end
+end

data/windows/monkey_patches/plugins/providers/virtualbox/driver/version_4_2.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Driver
+      class Version_4_2
+        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
+    end
+  end
+end

data/windows/monkey_patches/plugins/provisioners/chef/provisioner/chef_client.rb

@@ -0,0 +1 @@
+# TODO: support Chef client

data/windows/monkey_patches/plugins/provisioners/chef/provisioner/chef_solo.rb

@@ -0,0 +1,106 @@
+require 'tempfile'
+require "#{Vagrant::source_root}/plugins/provisioners/chef/provisioner/chef_solo"
+require_relative '../../../../../helper'
+
+module VagrantPlugins
+  module Chef
+    module Provisioner
+      class ChefSolo < Base
+        
+        include VagrantWindows::Helper
+
+        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
+          # create cheftaskrun.ps1 that the scheduled task will invoke when run
+          render_file_and_upload("cheftaskrun.ps1", chef_script_options[:chef_task_run_ps1], :options => chef_script_options)
+
+          # create cheftask.xml that the scheduled task will be created with
+          render_file_and_upload("cheftask.xml", chef_script_options[:chef_task_xml], :options => chef_script_options)
+
+          # create cheftask.ps1 that will immediately invoke the scheduled task and wait for completion
+          render_file_and_upload("cheftask.ps1", chef_script_options[:chef_task_ps1], :options => chef_script_options)
+          
+          command = <<-EOH
+          $old = Get-ExecutionPolicy;
+          Set-ExecutionPolicy Unrestricted -force;
+          #{chef_script_options[:chef_task_ps1]};
+          Set-ExecutionPolicy $old -force
+          exit $LASTEXITCODE
+          EOH
+
+          @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.execute(command) do |type, data|
+              # Output the data with the proper color based on the stream.
+              color = type == :stdout ? :green : :red
+
+              @machine.env.ui.info(
+                data, :color => color, :new_line => false, :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 render_file_and_upload(script_name, dest_file, options)
+          script_contents = VagrantWindows.load_script_template(script_name, options)
+
+          # render cheftaskrun.ps1 to local temp file
+          script_local = Tempfile.new(script_name)
+          IO.write(script_local, script_contents)
+          
+          # upload cheftaskrun.ps1 file
+          @machine.communicate.upload(script_local, dest_file)
+        end
+        
+        def chef_script_options
+          if @chef_script_options.nil?
+            command_env = @config.binary_env ? "#{@config.binary_env} " : ""
+            command_args = @config.arguments ? " #{@config.arguments}" : ""
+            chef_solo_path = win_friendly_path(File.join(@config.provisioning_path, 'solo.rb'))
+            chef_dna_path = win_friendly_path(File.join(@config.provisioning_path, 'dna.json'))
+          
+            chef_arguments = "-c #{chef_solo_path} "
+            chef_arguments << "-j #{chef_dna_path} "
+            chef_arguments << "#{command_args}"
+          
+            @chef_script_options = {
+              :user => @machine.config.winrm.username,
+              :pass => @machine.config.winrm.password,
+              :chef_arguments => chef_arguments,
+              :chef_task_xml => win_friendly_path("#{@config.provisioning_path}/cheftask.xml"),
+              :chef_task_running => win_friendly_path("#{@config.provisioning_path}/cheftask.running"),
+              :chef_task_exitcode => win_friendly_path("#{@config.provisioning_path}/cheftask.exitcode"),
+              :chef_task_ps1 => win_friendly_path("#{@config.provisioning_path}/cheftask.ps1"),
+              :chef_task_run_ps1 => win_friendly_path("#{@config.provisioning_path}/cheftaskrun.ps1"),
+              :chef_stdout_log => win_friendly_path("#{@config.provisioning_path}/chef-solo.log"),
+              :chef_stderr_log => win_friendly_path("#{@config.provisioning_path}/chef-solo.err.log"),
+              :chef_binary_path => win_friendly_path("#{command_env}#{chef_binary_path("chef-solo")}")
+            }
+          end
+          @chef_script_options
+        end        
+        
+        def is_windows
+          @machine.config.vm.guest.eql? :windows
+        end
+        
+      end # ChefSolo class
+    end
+  end
+end

data/windows/monkey_patches/plugins/provisioners/puppet/provisioner/puppet.rb

@@ -0,0 +1,101 @@
+require "#{Vagrant::source_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("/ProgramData/PuppetLabs/puppet/etc/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|
+            if !data.empty?
+              @machine.env.ui.info(data, :new_line => false, :prefix => false)
+            end
+          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.temp_dir, "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, :id => "v-modules-#{count}")
+            count += 1
+          end
+        end
+
+        def is_windows
+          @machine.config.vm.guest.eql? :windows
+        end
+
+      end # Puppet class
+    end
+  end
+end

data/windows/monkey_patches/plugins/provisioners/puppet/provisioner/puppet_server.rb

@@ -0,0 +1 @@
+#TODO: Support Puppet server

data/windows/monkey_patches/plugins/provisioners/shell/provisioner.rb

@@ -0,0 +1,89 @@
+require "#{Vagrant::source_root}/plugins/provisioners/shell/provisioner"
+require_relative '../../../../helper'
+
+module VagrantPlugins
+  module Shell
+      class Provisioner < Vagrant.plugin("2", :provisioner)
+        
+        include VagrantWindows::Helper
+
+        # This patch is needed until Vagrant supports Puppet on Windows guests
+        provision_on_linux = instance_method(:provision)
+        
+        define_method(:provision) do
+          is_windows ? provision_on_windows() : provision_on_linux.bind(self).()
+        end
+
+        def provision_on_windows
+            args = ""
+            args = " #{config.args}" if config.args
+
+            with_script_file do |path|
+            # Upload the script to the machine
+            @machine.communicate.tap do |comm|
+              # Ensure the uploaded script has a file extension, by default
+              # config.upload_path from vagrant core does not
+              fixed_upload_path = if File.extname(config.upload_path) == ""
+                "#{config.upload_path}#{File.extname(path.to_s)}"
+              else
+                config.upload_path
+              end
+              comm.upload(path.to_s, fixed_upload_path)
+
+              command = <<-EOH
+              $old = Get-ExecutionPolicy;
+              Set-ExecutionPolicy Unrestricted -force;
+              #{win_friendly_path(fixed_upload_path)}#{args};
+              Set-ExecutionPolicy $old -force
+              EOH
+              
+              # Execute it with sudo
+              comm.sudo(command) do |type, data|
+                if [:stderr, :stdout].include?(type)
+                  # Output the data with the proper color based on the stream.
+                  color = type == :stdout ? :green : :red
+
+                  @machine.ui.info(
+                    data,
+                    :color => color, :new_line => false, :prefix => false)
+                end
+              end
+              
+            end
+          end
+        end
+
+
+        protected
+
+        # This method yields the path to a script to upload and execute
+        # on the remote server. This method will properly clean up the
+        # script file if needed.
+        def with_script_file
+          if config.path
+            # Just yield the path to that file...
+            yield config.path
+          else
+            # Otherwise we have an inline script, we need to Tempfile it,
+            # and handle it specially...
+            file = Tempfile.new(['vagrant-powershell', '.ps1'])
+
+            begin
+              file.write(config.inline)
+              file.fsync
+              file.close
+              yield file.path
+            ensure
+              file.close
+              file.unlink
+            end
+          end
+        end
+
+        def is_windows
+            @machine.config.vm.guest.eql? :windows
+        end
+
+      end # Provisioner class
+  end
+end

data/windows/plugin.rb

@@ -0,0 +1,129 @@
+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
+
+if Vagrant::VERSION >= "1.2.0"
+  # Monkey Patch the virtualbox share_folders action to make valid share names on windows
+  require_relative "monkey_patches/plugins/providers/virtualbox/action/share_folders"
+end
+
+# Monkey patch the vbox42 driver to support read mac addresses
+require_relative "monkey_patches/plugins/providers/virtualbox/driver/version_4_2"
+
+# Monkey Patch the VM object to support multiple channels, i.e. WinRM
+require_relative "monkey_patches/lib/vagrant/machine"
+
+# Monkey patch the Puppet provisioners to support PowerShell/Windows
+require_relative "monkey_patches/plugins/provisioners/puppet/provisioner/puppet"
+require_relative "monkey_patches/plugins/provisioners/puppet/provisioner/puppet_server"
+
+# Monkey patch the Chef provisioners to support PowerShell/Windows
+require_relative "monkey_patches/plugins/provisioners/chef/provisioner/chef_solo"
+require_relative "monkey_patches/plugins/provisioners/chef/provisioner/chef_client"
+
+# Monkey patch the shell provisioner to support PowerShell/batch/exe/Windows/etc
+require_relative "monkey_patches/plugins/provisioners/shell/provisioner"
+
+
+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
+
+    config(:windows) do
+      require_relative "config/windows"
+      VagrantWindows::Config::Windows
+    end
+
+    config(:winrm) do
+      require_relative "config/winrm"
+      VagrantWindows::Config::WinRM
+    end
+
+    guest(:windows) do
+      require_relative "guest/windows"
+      VagrantWindows::Guest::Windows
+    end
+
+    # Vagrant 1.2 introduced the concept of capabilities instead of implementing
+    # an interface on the guest.
+    if Vagrant::VERSION >= "1.2.0"
+
+      guest_capability(:windows, :change_host_name) do
+        require_relative "guest/cap/change_host_name"
+        VagrantWindows::Guest::Cap::ChangeHostName
+      end
+
+      guest_capability(:windows, :configure_networks) do
+        require_relative "guest/cap/configure_networks"
+        VagrantWindows::Guest::Cap::ConfigureNetworks
+      end
+
+      guest_capability(:windows, :halt) do
+        require_relative "guest/cap/halt"
+        VagrantWindows::Guest::Cap::Halt
+      end
+
+      guest_capability(:windows, :mount_virtualbox_shared_folder) do
+        require_relative "guest/cap/mount_virtualbox_shared_folder"
+        VagrantWindows::Guest::Cap::MountVirtualBoxSharedFolder
+      end
+
+      guest_capability(:windows, :mount_vmware_shared_folder) do
+        require_relative "guest/cap/mount_vmware_shared_folder"
+        VagrantWindows::Guest::Cap::MountVMwareSharedFolder
+      end
+    
+    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/windows/scripts/cheftask.ps1.erb

@@ -0,0 +1,47 @@
+schtasks /query /tn "chef-solo" | Out-Null
+if ($?) {
+  # task already exists, kill it
+  schtasks /delete /tn "chef-solo" /f | Out-Null
+}
+
+# Ensure the chef task running file doesn't exist from a previous failure
+if (Test-Path "<%= options[:chef_task_running] %>") {
+  del "<%= options[:chef_task_running] %>"
+}
+
+# schedule the task to run once in the far distant future
+schtasks /create /tn "chef-solo" /xml "<%= options[:chef_task_xml] %>" /ru "<%= options[:user] %>" /rp "<%= options[:pass] %>" | Out-Null
+
+# start the scheduled task right now
+schtasks /run /tn "chef-solo" | Out-Null
+
+# wait for run_chef.ps1 to start or timeout after 1 minute
+$timeoutSeconds = 60
+$elapsedSeconds = 0
+while ( (!(Test-Path "<%= options[:chef_task_running] %>")) -and ($elapsedSeconds -lt $timeoutSeconds) ) {
+  Start-Sleep -s 1
+  $elapsedSeconds++
+}
+
+if ($elapsedSeconds -ge $timeoutSeconds) {
+  Write-Error "Timed out waiting for chef scheduled task to start"
+  exit -2
+}
+
+# read the entire file, but only write out new lines we haven't seen before
+$numLinesRead = 0
+$success = $TRUE
+while (Test-Path "<%= options[:chef_task_running] %>") {
+  Start-Sleep -m 100
+  
+  $text = (get-content "<%= options[:chef_stdout_log] %>")
+  $numLines = ($text | Measure-Object -line).lines    
+  $numLinesToRead = $numLines - $numLinesRead
+  
+  $text | select -first $numLinesToRead -skip $numLinesRead | ForEach {
+    Write-Host "$_"
+  }
+  $numLinesRead += $numLinesToRead
+}
+
+exit Get-Content "<%= options[:chef_task_exitcode] %>"

data/windows/scripts/cheftask.xml.erb

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Date>2013-06-21T22:41:43</Date>
+    <Author>Administrator</Author>
+  </RegistrationInfo>
+  <Triggers>
+    <TimeTrigger>
+      <StartBoundary>2045-01-01T12:00:00</StartBoundary>
+      <Enabled>true</Enabled>
+    </TimeTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>vagrant</UserId>
+      <LogonType>Password</LogonType>
+      <RunLevel>HighestAvailable</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>false</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <IdleSettings>
+      <StopOnIdleEnd>true</StopOnIdleEnd>
+      <RestartOnIdle>false</RestartOnIdle>
+    </IdleSettings>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>false</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <WakeToRun>false</WakeToRun>
+    <ExecutionTimeLimit>PT2H</ExecutionTimeLimit>
+    <Priority>7</Priority>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>powershell</Command>
+      <Arguments>-file <%= options[:chef_task_run_ps1] %></Arguments>
+    </Exec>
+  </Actions>
+</Task>

data/windows/scripts/cheftaskrun.ps1.erb

@@ -0,0 +1,16 @@
+$exitCode = -1
+Set-ExecutionPolicy Unrestricted -force;
+
+Try
+{
+  "running" | Out-File "<%= options[:chef_task_running] %>"
+  $process = (Start-Process "<%= options[:chef_binary_path] %>" -ArgumentList "<%= options[:chef_arguments] %>" -NoNewWindow -PassThru -Wait -RedirectStandardOutput "<%= options[:chef_stdout_log] %>" -RedirectStandardError "<%= options[:chef_stderr_log] %>")
+  $exitCode = $process.ExitCode
+}
+Finally
+{
+  $exitCode | Out-File "<%= options[:chef_task_exitcode] %>"
+  del "<%= options[:chef_task_running] %>"
+}
+
+exit $exitCode

data/windows/scripts/command_alias.ps1

@@ -0,0 +1,36 @@
+function which {
+    $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) {
+  if(Test-Path $path)
+  {
+    exit 0
+  }
+  exit 1
+}
+
+function chmod {
+  exit 0
+}
+
+function chown {
+  exit 0
+}
+
+function mkdir ([Switch] $p, [String] $path)
+{
+  if(Test-Path $path)
+  {
+    exit 0
+  } else {
+    New-Item $path -Type Directory -Force | Out-Null
+  }
+}
+