vagrant 1.5.0 → 2.4.4

data/plugins/communicators/ssh/plugin.rb

@@ -0,0 +1,22 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module CommunicatorSSH
+    class Plugin < Vagrant.plugin("2")
+      name "ssh communicator"
+      description <<-DESC
+      This plugin allows Vagrant to communicate with remote machines using
+      SSH as the underlying protocol, powered internally by Ruby's
+      net-ssh library.
+      DESC
+
+      communicator("ssh") do
+        require File.expand_path("../communicator", __FILE__)
+        Communicator
+      end
+    end
+  end
+end

data/plugins/communicators/winrm/command_filter.rb

@@ -0,0 +1,49 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    # Handles loading and applying all available WinRM command filters
+    class CommandFilter
+      @@cmd_filters = [
+        "cat",
+        "chmod",
+        "chown",
+        "grep",
+        "rm",
+        "test",
+        "uname",
+        "which",
+        "mkdir",
+      ]
+
+      # Filter the given Vagrant command to ensure compatibility with Windows
+      #
+      # @param [String] The Vagrant shell command
+      # @returns [String] Windows runnable command or empty string
+      def filter(command)
+        command_filters.each { |c| command = c.filter(command) if c.accept?(command) }
+        command
+      end
+
+      # All the available Linux command filters
+      #
+      # @returns [Array] All Linux command filter instances
+      def command_filters
+        @command_filters ||= create_command_filters()
+      end
+
+      private
+
+      def create_command_filters
+        [].tap do |filters|
+          @@cmd_filters.each do |cmd|
+            require_relative "command_filters/#{cmd}"
+            class_name = "VagrantPlugins::CommunicatorWinRM::CommandFilters::#{cmd.capitalize}"
+            filters << Module.const_get(class_name).new
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/communicators/winrm/command_filters/cat.rb

@@ -0,0 +1,26 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    module CommandFilters
+      # Handles the special case of determining the guest OS using cat
+      class Cat
+        def filter(command)
+          # cat /etc/release | grep -i OmniOS
+          # cat /etc/redhat-release
+          # cat /etc/issue | grep 'Core Linux'
+          # cat /etc/release | grep -i SmartOS
+          ''
+        end
+
+        def accept?(command)
+          # cat works in PowerShell, however we don't want to run Guest
+          # OS detection as this will fail on Windows because the lack of the
+          # grep command
+          command.start_with?('cat /etc/')
+        end
+      end
+    end
+  end
+end

data/plugins/communicators/winrm/command_filters/chmod.rb

@@ -0,0 +1,20 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    module CommandFilters
+      # Converts a *nix 'chmod' command to a PowerShell equivalent (none)
+      class Chmod
+        def filter(command)
+          # Not supported on Windows, the communicator should skip this command
+          ''
+        end
+
+        def accept?(command)
+          command.start_with?('chmod ')
+        end
+      end
+    end
+  end
+end

data/plugins/communicators/winrm/command_filters/chown.rb

@@ -0,0 +1,20 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    module CommandFilters
+      # Converts a *nix 'chown' command to a PowerShell equivalent (none)
+      class Chown
+        def filter(command)
+          # Not supported on Windows, the communicator should skip this command
+          ''
+        end
+
+        def accept?(command)
+          command.start_with?('chown ')
+        end
+      end
+    end
+  end
+end

data/plugins/communicators/winrm/command_filters/grep.rb

@@ -0,0 +1,26 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    module CommandFilters
+      # Converts a *nix 'grep' command to a PowerShell equivalent (none)
+      class Grep
+
+        def filter(command)
+          # grep 'Fedora release [12][67890]' /etc/redhat-release
+          # grep Funtoo /etc/gentoo-release
+          # grep Gentoo /etc/gentoo-release
+
+          # grep is often used to detect the guest type in Vagrant, so don't bother running
+          # to speed up OS detection
+          ''
+        end
+
+        def accept?(command)
+          command.start_with?('grep ')
+        end
+      end
+    end
+  end
+end

data/plugins/communicators/winrm/command_filters/mkdir.rb

@@ -0,0 +1,30 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "shellwords"
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    module CommandFilters
+      # Converts a *nix 'mkdir' command to a PowerShell equivalent
+      class Mkdir
+        def filter(command)
+          # mkdir -p /some/dir
+          # mkdir /some/dir
+          cmd_parts = Shellwords.split(command.strip)
+          dir = cmd_parts.pop
+          while !dir.nil? && dir.start_with?('-')
+            dir = cmd_parts.pop
+          end
+          # This will ignore any -p switches, which are redundant in PowerShell,
+          # and ambiguous in PowerShell 4+
+          return "mkdir \"#{dir}\" -force"
+        end
+
+        def accept?(command)
+          command.start_with?('mkdir ')
+        end
+      end
+    end
+  end
+end

data/plugins/communicators/winrm/command_filters/rm.rb

@@ -0,0 +1,50 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "shellwords"
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    module CommandFilters
+      # Converts a *nix 'rm' command to a PowerShell equivalent
+      class Rm
+        def filter(command)
+          # rm -Rf /some/dir
+          # rm -R /some/dir
+          # rm -R -f /some/dir
+          # rm -f /some/dir
+          # rm /some/dir
+          cmd_parts = Shellwords.split(command.strip)
+
+          # Figure out if we need to do this recursively
+          recurse = false
+          cmd_parts.each do |k|
+            argument = k.downcase
+            if argument == '-r' || argument == '-rf' || argument == '-fr'
+              recurse = true
+              break
+            end
+          end
+
+          # Figure out which argument is the path
+          dir = cmd_parts.pop
+          while !dir.nil? && dir.start_with?('-')
+            dir = cmd_parts.pop
+          end
+
+          ret_cmd = ''
+          if recurse
+            ret_cmd = "if (Test-Path \"#{dir}\") {Remove-Item \"#{dir}\" -force -recurse}"
+          else
+            ret_cmd = "if (Test-Path \"#{dir}\") {Remove-Item \"#{dir}\" -force}"
+          end
+          return ret_cmd
+        end
+
+        def accept?(command)
+          command.start_with?('rm ')
+        end
+      end
+    end
+  end
+end

data/plugins/communicators/winrm/command_filters/test.rb

@@ -0,0 +1,68 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "shellwords"
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    module CommandFilters
+      # Converts a *nix 'test' command to a PowerShell equivalent
+      class Test
+        def filter(command)
+          # test -d /tmp/dir
+          # test -f /tmp/afile
+          # test -L /somelink
+          # test -x /tmp/some.exe
+
+          cmd_parts = Shellwords.split(command.strip)
+          flag = cmd_parts[1]
+          path = cmd_parts[2]
+
+          if flag == '-d'
+            check_for_directory(path)
+          elsif flag == '-f' || flag == '-x'
+            check_for_file(path)
+          else
+            check_exists(path)
+          end
+        end
+
+        def accept?(command)
+          command.start_with?("test ")
+        end
+
+        private
+
+        def check_for_directory(path)
+          <<-EOH
+            $p = "#{path}"
+            if ((Test-Path $p) -and (get-item $p).PSIsContainer) {
+              exit 0
+            }
+            exit 1
+          EOH
+        end
+
+        def check_for_file(path)
+          <<-EOH
+            $p = "#{path}"
+            if ((Test-Path $p) -and (!(get-item $p).PSIsContainer)) {
+              exit 0
+            }
+            exit 1
+          EOH
+        end
+
+        def check_exists(path)
+          <<-EOH
+            $p = "#{path}"
+            if (Test-Path $p) {
+              exit 0
+            }
+            exit 1
+          EOH
+        end
+      end
+    end
+  end
+end

data/plugins/communicators/winrm/command_filters/uname.rb

@@ -0,0 +1,30 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    module CommandFilters
+      # Converts a *nix 'uname' command to a PowerShell equivalent (none)
+      class Uname
+        def filter(command)
+          # uname -s | grep 'Darwin'
+          # uname -s | grep VMkernel
+          # uname -s | grep 'FreeBSD'
+          # uname -s | grep 'Linux'
+          # uname -s | grep NetBSD
+          # uname -s | grep 'OpenBSD'
+          # uname -sr | grep SunOS | grep -v 5.11
+          # uname -sr | grep 'SunOS 5.11'
+
+          # uname is used to detect the guest type in Vagrant, so don't bother running
+          # to speed up OS detection
+          ''
+        end
+
+        def accept?(command)
+          command.start_with?('uname ')
+        end
+      end
+    end
+  end
+end

data/plugins/communicators/winrm/command_filters/which.rb

@@ -0,0 +1,27 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "shellwords"
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    module CommandFilters
+      # Converts a *nix 'which' command to a PowerShell equivalent
+      class Which
+        def filter(command)
+          executable = Shellwords.split(command.strip)[1]
+          return <<-EOH
+            $command = [Array](Get-Command "#{executable}" -errorAction SilentlyContinue)
+            if ($null -eq $command) { exit 1 }
+            write-host $command[0].Definition
+            exit 0
+          EOH
+        end
+
+        def accept?(command)
+          command.start_with?('which ')
+        end
+      end
+    end
+  end
+end

data/plugins/communicators/winrm/communicator.rb

@@ -0,0 +1,230 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+require "tempfile"
+require "timeout"
+
+require_relative "helper"
+require_relative "shell"
+require_relative "command_filter"
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    # Provides communication channel for Vagrant commands via WinRM.
+    class Communicator < Vagrant.plugin("2", :communicator)
+      include Vagrant::Util
+
+      def self.match?(machine)
+        # This is useless, and will likely be removed in the future (this
+        # whole method).
+        true
+      end
+
+      def initialize(machine)
+        @cmd_filter = CommandFilter.new()
+        @logger     = Log4r::Logger.new("vagrant::communication::winrm")
+        @machine    = machine
+        @shell      = nil
+
+        @logger.info("Initializing WinRMCommunicator")
+      end
+
+      def wait_for_ready(timeout)
+        Timeout.timeout(timeout) do
+          # Wait for winrm_info to be ready
+          winrm_info = nil
+          while true
+            winrm_info = nil
+            begin
+              winrm_info = Helper.winrm_info(@machine)
+            rescue Errors::WinRMNotReady
+              @logger.debug("WinRM not ready yet; retrying until boot_timeout is reached.")
+            end
+            break if winrm_info
+            sleep 0.5
+          end
+
+          # Got it! Let the user know what we're connecting to.
+          @machine.ui.detail("WinRM address: #{shell.host}:#{shell.port}")
+          @machine.ui.detail("WinRM username: #{shell.username}")
+          @machine.ui.detail("WinRM execution_time_limit: #{shell.execution_time_limit}")
+          @machine.ui.detail("WinRM transport: #{shell.config.transport}")
+
+          last_message = nil
+          last_message_repeat_at = 0
+          while true
+            message  = nil
+            begin
+              begin
+                return true if ready?
+              rescue Vagrant::Errors::VagrantError => e
+                @logger.info("WinRM not ready: #{e.inspect}")
+                raise
+              end
+            rescue Errors::ConnectionTimeout
+              message = "Connection timeout."
+            rescue Errors::AuthenticationFailed
+              message = "Authentication failure."
+            rescue Errors::Disconnected
+              message = "Remote connection disconnect."
+            rescue Errors::ConnectionRefused
+              message = "Connection refused."
+            rescue Errors::ConnectionReset
+              message = "Connection reset."
+            rescue Errors::HostDown
+              message = "Host appears down."
+            rescue Errors::NoRoute
+              message = "Host unreachable."
+            rescue Errors::TransientError => e
+              # Any other retryable errors
+              message = e.message
+            end
+
+            # If we have a message to show, then show it. We don't show
+            # repeated messages unless they've been repeating longer than
+            # 10 seconds.
+            if message
+              message_at   = Time.now.to_f
+              show_message = true
+              if last_message == message
+                show_message = (message_at - last_message_repeat_at) > 10.0
+              end
+
+              if show_message
+                @machine.ui.detail("Warning: #{message} Retrying...")
+                last_message = message
+                last_message_repeat_at = message_at
+              end
+            end
+          end
+        end
+      rescue Timeout::Error
+        return false
+      end
+
+      def ready?
+        @logger.info("Checking whether WinRM is ready...")
+
+        result = Timeout.timeout(@machine.config.winrm.timeout) do
+          shell(true).cmd("hostname")
+        end
+
+        @logger.info("WinRM is ready!")
+        return true
+      rescue Errors::TransientError, VagrantPlugins::CommunicatorWinRM::Errors::WinRMNotReady => e
+        # We catch a `TransientError` which would signal that something went
+        # that might work if we wait and retry.
+        @logger.info("WinRM not up: #{e.inspect}")
+
+        # We reset the shell to trigger calling of winrm_finder again.
+        # This resolves a problem when using vSphere where the winrm_info was not refreshing
+        # thus never getting the correct hostname.
+        @shell = nil
+        return false
+      end
+
+      def reset!
+        shell(true)
+      end
+
+      def shell(reload=false)
+        @shell = nil if reload
+        @shell ||= create_shell
+      end
+
+      def execute(command, opts={}, &block)
+        # If this is a *nix command with no Windows equivalent, don't run it
+        command = @cmd_filter.filter(command)
+        return 0 if command.empty?
+
+        opts = {
+          command:     command,
+          elevated:    false,
+          error_check: true,
+          error_class: Errors::WinRMBadExitStatus,
+          error_key:   nil, # use the error_class message key
+          good_exit:   0,
+          shell:       :powershell,
+          interactive: false,
+        }.merge(opts || {})
+
+        opts[:shell] = :elevated if opts[:elevated]
+        opts[:good_exit] = Array(opts[:good_exit])
+        @logger.debug("#{opts[:shell]} executing:\n#{command}")
+        output = shell.send(opts[:shell], command, opts, &block)
+        execution_output(output, opts)
+      end
+      alias_method :sudo, :execute
+
+      def test(command, opts=nil)
+        # If this is a *nix command (which we know about) with no Windows
+        # equivalent, assume failure
+        command = @cmd_filter.filter(command)
+        return false if command.empty?
+
+        opts = {
+          command:     command,
+          elevated:    false,
+          error_check: false,
+        }.merge(opts || {})
+
+        # If we're passed a *nix command which PS can't parse we get exit code
+        # 0, but output in stderr. We need to check both exit code and stderr.
+        output = shell.send(:powershell, command)
+        return output.exitcode == 0 && output.stderr.length == 0
+      end
+
+      def upload(from, to)
+        @logger.info("Uploading: #{from} to #{to}")
+        shell.upload(from, to)
+      end
+
+      def download(from, to)
+        @logger.info("Downloading: #{from} to #{to}")
+        shell.download(from, to)
+      end
+
+      protected
+
+      # This creates a new WinRMShell based on the information we know
+      # about this machine.
+      def create_shell
+        winrm_info = Helper.winrm_info(@machine)
+
+        WinRMShell.new(
+          winrm_info[:host],
+          winrm_info[:port],
+          @machine.config.winrm
+        )
+      end
+
+      # Handles the raw WinRM shell result and converts it to a
+      # standard Vagrant communicator result
+      def execution_output(output, opts)
+        if opts[:shell] == :wql
+          return output
+        elsif opts[:error_check] && \
+          !opts[:good_exit].include?(output.exitcode)
+          raise_execution_error(output, opts)
+        end
+        output.exitcode
+      end
+
+      def raise_execution_error(output, opts)
+        # WinRM can return multiple stderr and stdout entries
+        error_opts = opts.merge(
+          stdout: output.stdout,
+          stderr: output.stderr
+        )
+
+        # Use a different error message key if the caller gave us one,
+        # otherwise use the error's default message
+        error_opts[:_key] = opts[:error_key] if opts[:error_key]
+
+        # Raise the error, use the type the caller gave us or the comm default
+        raise opts[:error_class], error_opts
+      end
+    end #WinRM class
+  end
+end

data/plugins/communicators/winrm/config.rb

@@ -0,0 +1,76 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    class Config < 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 :retry_delay
+      attr_accessor :timeout
+      attr_accessor :transport
+      attr_accessor :ssl_peer_verification
+      attr_accessor :execution_time_limit
+      attr_accessor :basic_auth_only
+      attr_accessor :codepage
+
+      def initialize
+        @username               = UNSET_VALUE
+        @password               = UNSET_VALUE
+        @host                   = UNSET_VALUE
+        @port                   = UNSET_VALUE
+        @guest_port             = UNSET_VALUE
+        @max_tries              = UNSET_VALUE
+        @retry_delay            = UNSET_VALUE
+        @timeout                = UNSET_VALUE
+        @transport              = UNSET_VALUE
+        @ssl_peer_verification  = UNSET_VALUE
+        @execution_time_limit   = UNSET_VALUE
+        @basic_auth_only        = UNSET_VALUE
+        @codepage               = UNSET_VALUE
+      end
+
+      def finalize!
+        @username = "vagrant"   if @username == UNSET_VALUE
+        @password = "vagrant"   if @password == UNSET_VALUE
+        @transport = :negotiate if @transport == UNSET_VALUE
+        @host = nil           if @host == UNSET_VALUE
+        is_ssl = @transport == :ssl
+        @port = (is_ssl ? 5986 : 5985)       if @port == UNSET_VALUE
+        @guest_port = (is_ssl ? 5986 : 5985) if @guest_port == UNSET_VALUE
+        @max_tries = 20        if @max_tries == UNSET_VALUE
+        @retry_delay = 2       if @retry_delay == UNSET_VALUE
+        @timeout = 1800        if @timeout == UNSET_VALUE
+        @ssl_peer_verification = true if @ssl_peer_verification == UNSET_VALUE
+        @execution_time_limit = "PT2H"   if @execution_time_limit == UNSET_VALUE
+        @basic_auth_only = false    if @basic_auth_only == UNSET_VALUE
+        @codepage = nil        if @codepage == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+
+        errors << "winrm.username cannot be nil."    if @username.nil?
+        errors << "winrm.password cannot be nil."    if @password.nil?
+        errors << "winrm.port cannot be nil."        if @port.nil?
+        errors << "winrm.guest_port cannot be nil."  if @guest_port.nil?
+        errors << "winrm.max_tries cannot be nil."   if @max_tries.nil?
+        errors << "winrm.retry_delay cannot be nil." if @retry_delay.nil?
+        errors << "winrm.timeout cannot be nil."     if @timeout.nil?
+        errors << "winrm.execution_time_limit cannot be nil."     if @execution_time_limit.nil?
+        unless @ssl_peer_verification == true || @ssl_peer_verification == false
+          errors << "winrm.ssl_peer_verification must be a boolean."
+        end
+        unless @basic_auth_only == true || @basic_auth_only == false
+          errors << "winrm.basic_auth_only must be a boolean."
+        end
+
+        { "WinRM" => errors }
+      end
+    end
+  end
+end