vagrant 1.5.0 → 2.4.4

data/plugins/commands/plugin/gem_helper.rb

@@ -0,0 +1,89 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "rubygems"
+require "rubygems/config_file"
+require "rubygems/gem_runner"
+
+require "log4r"
+
+module VagrantPlugins
+  module CommandPlugin
+    # This class provides methods to help with calling out to the
+    # `gem` command but using the RubyGems API.
+    class GemHelper
+      def initialize(gem_home)
+        @gem_home = gem_home.to_s
+        @logger   = Log4r::Logger.new("vagrant::plugins::plugincommand::gemhelper")
+      end
+
+      # This will yield the given block with the proper ENV setup so
+      # that RubyGems only sees the gems in the Vagrant-managed gem
+      # path.
+      def with_environment
+        old_gem_home = ENV["GEM_HOME"]
+        old_gem_path = ENV["GEM_PATH"]
+        ENV["GEM_HOME"] = @gem_home
+        ENV["GEM_PATH"] = @gem_home
+        @logger.debug("Set GEM_* to: #{ENV["GEM_HOME"]}")
+
+        # Clear paths so that it reads the new GEM_HOME setting
+        Gem.paths = ENV
+
+        # Set a custom configuration to avoid loading ~/.gemrc loads and
+        # /etc/gemrc and so on.
+        old_config = nil
+        begin
+          old_config = Gem.configuration
+        rescue Psych::SyntaxError
+          # Just ignore this. This means that the ".gemrc" file has
+          # an invalid syntax and can't be loaded. We don't care, because
+          # when we set Gem.configuration to nil later, it'll force a reload
+          # if it is needed.
+        end
+        Gem.configuration = NilGemConfig.new
+
+        # Clear the sources so that installation uses custom sources
+        old_sources = Gem.sources
+        Gem.sources = Gem.default_sources
+        Vagrant::Bundler::DEFAULT_GEM_SOURCES.each do |source|
+          if !Gem.sources.include?(source)
+            Gem.sources << source
+          end
+        end
+
+        # Use a silent UI so that we have no output
+        Gem::DefaultUserInteraction.use_ui(Gem::SilentUI.new) do
+          return yield
+        end
+      ensure
+        # Restore the old GEM_* settings
+        ENV["GEM_HOME"] = old_gem_home
+        ENV["GEM_PATH"] = old_gem_path
+
+        # Reset everything
+        Gem.configuration = old_config
+        Gem.paths   = ENV
+        Gem.sources = old_sources.to_a
+      end
+
+      # This is pretty hacky but it is a custom implementation of
+      # Gem::ConfigFile so that we don't load any gemrc files.
+      class NilGemConfig < Gem::ConfigFile
+        def initialize
+          # We _can not_ `super` here because that can really mess up
+          # some other configuration state. We need to just set everything
+          # directly.
+
+          @api_keys       = {}
+          @args           = []
+          @backtrace      = false
+          @bulk_threshold = 1000
+          @hash           = {}
+          @update_sources = true
+          @verbose        = true
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/plugin.rb

@@ -0,0 +1,23 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module CommandPlugin
+    class Plugin < Vagrant.plugin("2")
+      name "plugin command"
+      description <<-DESC
+      This command helps manage and install plugins within the
+      Vagrant environment.
+DESC
+
+      command("plugin") do
+        require File.expand_path("../command/root", __FILE__)
+        Command::Root
+      end
+    end
+
+    autoload :Action, File.expand_path("../action", __FILE__)
+  end
+end

data/plugins/commands/port/command.rb

@@ -0,0 +1,91 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/util/presence"
+
+require "optparse"
+
+module VagrantPlugins
+  module CommandPort
+    class Command < Vagrant.plugin("2", :command)
+      include Vagrant::Util::Presence
+
+      def self.synopsis
+        "displays information about guest port mappings"
+      end
+
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant port [options] [name|id]"
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.on("--guest PORT", "Output the host port that maps to the given guest port") do |port|
+            options[:guest] = port
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        with_target_vms(argv, single_target: true) do |vm|
+          vm.action_raw(:config_validate,
+            Vagrant::Action::Builtin::ConfigValidate)
+
+          if !vm.provider.capability?(:forwarded_ports)
+            @env.ui.error(I18n.t("port_command.missing_capability",
+              provider: vm.provider_name,
+            ))
+            return 1
+          end
+
+          ports = vm.provider.capability(:forwarded_ports)
+
+          if !present?(ports)
+            @env.ui.info(I18n.t("port_command.empty_ports"))
+            return 0
+          end
+
+          if present?(options[:guest])
+            return print_single(vm, ports, options[:guest])
+          else
+            return print_all(vm, ports)
+          end
+        end
+      end
+
+      private
+
+      # Print all the guest <=> host port mappings.
+      # @return [0] the exit code
+      def print_all(vm, ports)
+        @env.ui.info(I18n.t("port_command.details"))
+        @env.ui.info("")
+        ports.each do |host, guest|
+          @env.ui.info("#{guest.to_s.rjust(6)} (guest) => #{host} (host)")
+          @env.ui.machine("forwarded_port", guest, host, target: vm.name.to_s)
+        end
+        return 0
+      end
+
+      # Print the host mapping that matches the given guest target.
+      # @return [0,1] the exit code
+      def print_single(vm, ports, target)
+        map = ports.find { |_, guest| "#{guest}" == "#{target}" }
+        if !present?(map)
+          @env.ui.error(I18n.t("port_command.no_matching_port",
+            port: target,
+          ))
+          return 1
+        end
+
+        @env.ui.info("#{map[0]}")
+        return 0
+      end
+    end
+  end
+end

data/plugins/commands/port/locales/en.yml

@@ -0,0 +1,23 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+en:
+  port_command:
+    details: |-
+      The forwarded ports for the machine are listed below. Please note that
+      these values may differ from values configured in the Vagrantfile if the
+      provider supports automatic port collision detection and resolution.
+    empty_ports: |-
+      The provider reported there are no forwarded ports for this virtual
+      machine. This can be caused if there are no ports specified in the
+      Vagrantfile or if the virtual machine is not currently running. Please
+      check that the virtual machine is running and try again.
+    missing_capability: |-
+      The %{provider} provider does not support listing forwarded ports. This is
+      most likely a limitation of the provider and not a bug in Vagrant. If you
+      believe this is a bug in Vagrant, please search existing issues before
+      opening a new one.
+    no_matching_port: |-
+      The guest is not currently mapping port %{port} to the host machine. Is
+      the port configured in the Vagrantfile? You may need to run `vagrant reload`
+      if changes were made to the port configuration in the Vagrantfile.

data/plugins/commands/port/plugin.rb

@@ -0,0 +1,30 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module CommandPort
+    class Plugin < Vagrant.plugin("2")
+      name "port command"
+      description <<-DESC
+      The `port` command displays guest port mappings.
+      DESC
+
+      command("port") do
+        require_relative "command"
+        self.init!
+        Command
+      end
+
+      protected
+
+      def self.init!
+        return if defined?(@_init)
+        I18n.load_path << File.expand_path("../locales/en.yml", __FILE__)
+        I18n.reload!
+        @_init = true
+      end
+    end
+  end
+end

data/plugins/commands/powershell/command.rb

@@ -0,0 +1,132 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "optparse"
+
+require "vagrant/util/powershell"
+require_relative "../../communicators/winrm/helper"
+
+module VagrantPlugins
+  module CommandPS
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "connects to machine via powershell remoting"
+      end
+
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant powershell [-- extra powershell args]"
+
+          o.separator ""
+          o.separator "Opens a PowerShell session on the host to the guest"
+          o.separator "machine if both support powershell remoting."
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.on("-c", "--command COMMAND", "Execute a powershell command directly") do |c|
+            options[:command] = c
+          end
+
+          o.on("-e", "--elevated", "Execute a powershell command with elevated permissions") do |c|
+            options[:elevated] = true
+          end
+        end
+
+        # Parse out the extra args to send to the ps session, which
+        # is everything after the "--"
+        split_index = @argv.index("--")
+        if split_index
+          options[:extra_args] = @argv.drop(split_index + 1)
+          @argv                = @argv.take(split_index)
+        end
+
+        # Parse the options and return if we don't have any target.
+        argv = parse_options(opts)
+        return if !argv
+
+        # Elevated option enabled means we can only execute commands
+        raise Errors::ElevatedNoCommand if !options[:command] && options[:elevated]
+
+        # Execute ps session if we can
+        with_target_vms(argv, single_target: true) do |machine|
+          if !machine.communicate.ready?
+            raise Vagrant::Errors::VMNotCreatedError
+          end
+
+          if options[:command]
+            if machine.config.vm.communicator != :winrm
+              raise VagrantPlugins::CommunicatorWinRM::Errors::WinRMNotReady
+            end
+
+            out_code = machine.communicate.execute(options[:command].dup, elevated: options[:elevated]) do |type,data|
+              machine.ui.detail(data) if type == :stdout
+            end
+            if out_code == 0
+              machine.ui.success("Command: #{options[:command]} executed successfully with output code #{out_code}.")
+            end
+            next
+          end
+
+          # Check if the host even supports ps remoting
+          raise Errors::HostUnsupported if !@env.host.capability?(:ps_client)
+
+          ps_info = VagrantPlugins::CommunicatorWinRM::Helper.winrm_info(machine)
+          ps_info[:username] = machine.config.winrm.username
+          ps_info[:password] = machine.config.winrm.password
+          # Extra arguments if we have any
+          ps_info[:extra_args] = options[:extra_args]
+
+          result = ready_ps_remoting_for(machine, ps_info)
+
+          machine.ui.detail(
+            "Creating powershell session to #{ps_info[:host]}:#{ps_info[:port]}")
+          machine.ui.detail("Username: #{ps_info[:username]}")
+
+          begin
+            @env.host.capability(:ps_client, ps_info)
+          ensure
+            if result["PreviousTrustedHosts"]
+              reset_ps_remoting_for(machine, ps_info)
+            end
+          end
+        end
+      end
+
+      def ready_ps_remoting_for(machine, ps_info)
+        machine.ui.output(I18n.t("vagrant_ps.detecting"))
+        script_path = File.expand_path("../scripts/enable_psremoting.ps1", __FILE__)
+        args = []
+        args << "-hostname" << ps_info[:host]
+        args << "-port" << ps_info[:port].to_s
+        args << "-username" << ps_info[:username]
+        args << "-password" << ps_info[:password]
+        result = Vagrant::Util::PowerShell.execute(script_path, *args)
+        if result.exit_code != 0
+          raise Errors::PowerShellError,
+            script: script_path,
+            stderr: result.stderr
+        end
+
+        result_output = JSON.parse(result.stdout)
+        raise Errors::PSRemotingUndetected if !result_output["Success"]
+        result_output
+      end
+
+      def reset_ps_remoting_for(machine, ps_info)
+        machine.ui.output(I18n.t("vagrant_ps.resetting"))
+        script_path = File.expand_path("../scripts/reset_trustedhosts.ps1", __FILE__)
+        args = []
+        args << "-hostname" << ps_info[:host]
+        result = Vagrant::Util::PowerShell.execute(script_path, *args)
+        if result.exit_code != 0
+          raise Errors::PowerShellError,
+            script: script_path,
+            stderr: result.stderr
+        end
+      end
+    end
+  end
+end

data/plugins/commands/powershell/errors.rb

@@ -0,0 +1,29 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module CommandPS
+    module Errors
+      # A convenient superclass for all our errors.
+      class PSCommandError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_ps.errors")
+      end
+
+      class HostUnsupported < PSCommandError
+        error_key(:host_unsupported)
+      end
+
+      class PSRemotingUndetected < PSCommandError
+        error_key(:ps_remoting_undetected)
+      end
+
+      class PowerShellError < PSCommandError
+        error_key(:powershell_error)
+      end
+
+      class ElevatedNoCommand < PSCommandError
+        error_key(:elevated_no_command)
+      end
+    end
+  end
+end

data/plugins/commands/powershell/plugin.rb

@@ -0,0 +1,34 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module CommandPS
+    autoload :Errors, File.expand_path("../errors", __FILE__)
+
+    class Plugin < Vagrant.plugin("2")
+      name "powershell command"
+      description <<-DESC
+      The powershell command opens a remote PowerShell session to the
+      machine if it supports powershell remoting.
+      DESC
+
+      command("powershell") do
+        require_relative "command"
+        init!
+        Command
+      end
+
+      protected
+
+      def self.init!
+        return if defined?(@_init)
+        I18n.load_path << File.expand_path("templates/locales/command_ps.yml", Vagrant.source_root)
+        I18n.load_path << File.expand_path("templates/locales/comm_winrm.yml", Vagrant.source_root)
+        I18n.reload!
+        @_init = true
+      end
+    end
+  end
+end

data/plugins/commands/powershell/scripts/enable_psremoting.ps1

@@ -0,0 +1,63 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+Param(
+    [string]$hostname,
+    [string]$port,
+    [string]$username,
+    [string]$password
+)
+# If we are in this script, we know basic winrm is working
+# If the user is not using a domain account and chances are
+# they are not, PS Remoting will not work if the guest is not
+# listed in the trusted hosts.
+
+$encrypted_password = ConvertTo-SecureString $password -asplaintext -force
+$creds = New-Object System.Management.Automation.PSCredential (
+    "$hostname\\$username", $encrypted_password)
+
+$result = @{
+    Success = $false
+    PreviousTrustedHosts = $null
+}
+try {
+    invoke-command -computername $hostname `
+                   -Credential $creds `
+                   -Port $port `
+                   -ScriptBlock {} `
+                   -ErrorAction Stop
+    $result.Success = $true
+} catch{}
+
+if(!$result.Success) { 
+    $newHosts = @()
+    $result.PreviousTrustedHosts=(
+        Get-Item "wsman:\localhost\client\trustedhosts").Value
+    $hostArray=$result.PreviousTrustedHosts.Split(",").Trim()
+    if($hostArray -contains "*") {
+        $result.PreviousTrustedHosts = $null
+    }
+    elseif(!($hostArray -contains $hostname)) {
+        $strNewHosts = $hostname
+        if($result.PreviousTrustedHosts.Length -gt 0){
+            $strNewHosts = $result.PreviousTrustedHosts + "," + $strNewHosts
+        }
+        Set-Item -Path "wsman:\localhost\client\trustedhosts" `
+          -Value $strNewHosts -Force
+
+        try {
+            invoke-command -computername $hostname `
+                           -Credential $creds `
+                           -Port $port `
+                           -ScriptBlock {} `
+                           -ErrorAction Stop
+            $result.Success = $true
+        } catch{
+            Set-Item -Path "wsman:\localhost\client\trustedhosts" `
+              -Value $result.PreviousTrustedHosts -Force
+            $result.PreviousTrustedHosts = $null
+        }
+    }
+}
+
+Write-Output $(ConvertTo-Json $result)

data/plugins/commands/powershell/scripts/reset_trustedhosts.ps1

@@ -0,0 +1,15 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+Param(
+    [string]$hostname
+)
+
+$trustedHosts = (
+    Get-Item "wsman:\localhost\client\trustedhosts").Value.Replace(
+    $hostname, '')
+$trustedHosts = $trustedHosts.Replace(",,","")
+if($trustedHosts.EndsWith(",")){
+    $trustedHosts = $trustedHosts.Substring(0,$trustedHosts.length-1)
+}
+Set-Item "wsman:\localhost\client\trustedhosts" -Value $trustedHosts -Force

data/plugins/commands/provider/command.rb

@@ -0,0 +1,77 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CommandProvider
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "show provider for this environment"
+      end
+
+      def execute
+        options = {}
+        options[:install] = false
+        options[:usable] = false
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant provider [options] [args]"
+          o.separator ""
+          o.separator "This command interacts with the provider for this environment."
+          o.separator "With no arguments, it'll output the default provider for this"
+          o.separator "environment."
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.on("--install", "Installs the provider if possible") do |f|
+            options[:install] = f
+          end
+
+          o.on("--usable", "Checks if the named provider is usable") do |f|
+            options[:usable] = f
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        # Get the machine
+        machine = nil
+        with_target_vms(argv, single_target: true) do |m|
+          machine = m
+        end
+
+        # Output some machine readable stuff
+        @env.ui.machine("provider-name", machine.provider_name, target: machine.name.to_s)
+
+        # Check if we're just doing a usability check
+        if options[:usable]
+          @env.ui.output(machine.provider_name.to_s)
+          return 0 if machine.provider.class.usable?(false)
+          return 1
+        end
+
+        # Check if we're requesting installation
+        if options[:install]
+          key = "provider_install_#{machine.provider_name}".to_sym
+          if !@env.host.capability?(key)
+            raise Vagrant::Errors::ProviderCantInstall,
+              provider: machine.provider_name.to_s
+          end
+
+          @env.host.capability(key)
+          return
+        end
+
+        # No subtask, just output the provider name
+        @env.ui.output(machine.provider_name.to_s)
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/provider/plugin.rb

@@ -0,0 +1,21 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module CommandProvider
+    class Plugin < Vagrant.plugin("2")
+      name "provider command"
+      description <<-DESC
+      The `provider` command is used to interact with the various providers
+      that are installed with Vagrant.
+      DESC
+
+      command("provider", primary: false) do
+        require_relative "command"
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/provision/command.rb

@@ -0,0 +1,41 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CommandProvision
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "provisions the vagrant machine"
+      end
+
+      def execute
+        options = {}
+        options[:provision_types] = nil
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant provision [vm-name] [--provision-with x,y,z]"
+
+          o.on("--provision-with x,y,z", Array,
+                    "Enable only certain provisioners, by type or by name.") do |list|
+            options[:provision_types] = list.map { |type| type.to_sym }
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        # Go over each VM and provision!
+        @logger.debug("'provision' each target VM...")
+        with_target_vms(argv) do |machine|
+          machine.action(:provision, options)
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end