vagrant 1.5.0 → 2.4.4

data/plugins/communicators/winssh/communicator.rb

@@ -0,0 +1,252 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require File.expand_path("../../ssh/communicator", __FILE__)
+
+require "net/sftp"
+
+module VagrantPlugins
+  module CommunicatorWinSSH
+    # This class provides communication with a Windows VM running
+    # the Windows native port of OpenSSH
+    class Communicator < VagrantPlugins::CommunicatorSSH::Communicator
+      # Command to run when checking if connection is ready and working
+      READY_COMMAND="dir"
+
+      def initialize(machine)
+        super
+        @logger = Log4r::Logger.new("vagrant::communication::winssh")
+      end
+
+      # Wrap the shell if required. By default we are using powershell
+      # which requires no modification. If cmd is defined as shell, add
+      # prefix to start within cmd.exe
+      def shell_cmd(opts)
+        case opts[:shell].to_s
+        when "cmd"
+          "cmd.exe /c '#{opts[:command]}'"
+        else
+          opts[:command]
+        end
+      end
+
+      # Executes the command on an SSH connection within a login shell.
+      def shell_execute(connection, command, **opts)
+        opts[:shell] ||= machine_config_ssh.shell
+
+        command = shell_cmd(opts.merge(command: command))
+
+        @logger.info("Execute: #{command} - opts: #{opts}")
+        exit_status = nil
+
+        # Open the channel so we can execute or command
+        channel = connection.open_channel do |ch|
+          marker_found = false
+          data_buffer = ''
+          stderr_marker_found = false
+          stderr_data_buffer = ''
+
+          @logger.debug("Base SSH exec command: #{command}")
+          command = "$ProgressPreference = 'SilentlyContinue';Write-Output #{CMD_GARBAGE_MARKER};[Console]::Error.WriteLine('#{CMD_GARBAGE_MARKER}');#{command}"
+
+          ch.exec(command) do |ch2, _|
+            # Setup the channel callbacks so we can get data and exit status
+            ch2.on_data do |ch3, data|
+              # Filter out the clear screen command
+              data = remove_ansi_escape_codes(data)
+
+              if !marker_found
+                data_buffer << data
+                marker_index = data_buffer.index(CMD_GARBAGE_MARKER)
+                if marker_index
+                  marker_found = true
+                  data_buffer.slice!(0, marker_index + CMD_GARBAGE_MARKER.size)
+                  data.replace(data_buffer)
+                  data_buffer = nil
+                end
+              end
+
+              if block_given? && marker_found
+                yield :stdout, data
+              end
+            end
+
+            ch2.on_extended_data do |ch3, type, data|
+              # Filter out the clear screen command
+              data = remove_ansi_escape_codes(data)
+              @logger.debug("stderr: #{data}")
+              if !stderr_marker_found
+                stderr_data_buffer << data
+                marker_index = stderr_data_buffer.index(CMD_GARBAGE_MARKER)
+                if marker_index
+                  stderr_marker_found = true
+                  stderr_data_buffer.slice!(0, marker_index + CMD_GARBAGE_MARKER.size)
+                  data.replace(stderr_data_buffer.lstrip)
+                  data_buffer = nil
+                end
+              end
+
+              if block_given? && stderr_marker_found && !data.empty?
+                yield :stderr, data
+              end
+            end
+
+            ch2.on_request("exit-status") do |ch3, data|
+              exit_status = data.read_long
+              @logger.debug("Exit status: #{exit_status}")
+
+              # Close the channel, since after the exit status we're
+              # probably done. This fixes up issues with hanging.
+              ch.close
+            end
+
+          end
+        end
+
+        begin
+          keep_alive = nil
+
+          if @machine.config.ssh.keep_alive
+            # Begin sending keep-alive packets while we wait for the script
+            # to complete. This avoids connections closing on long-running
+            # scripts.
+            keep_alive = Thread.new do
+              loop do
+                sleep 5
+                @logger.debug("Sending SSH keep-alive...")
+                connection.send_global_request("keep-alive@openssh.com")
+              end
+            end
+          end
+
+          # Wait for the channel to complete
+          begin
+            channel.wait
+          rescue Errno::ECONNRESET, IOError
+            @logger.info(
+              "SSH connection unexpected closed. Assuming reboot or something.")
+            exit_status = 0
+            pty = false
+          rescue Net::SSH::ChannelOpenFailed
+            raise Vagrant::Errors::SSHChannelOpenFail
+          rescue Net::SSH::Disconnect
+            raise Vagrant::Errors::SSHDisconnected
+          end
+        ensure
+          # Kill the keep-alive thread
+          keep_alive.kill if keep_alive
+        end
+
+        # Return the final exit status
+        return exit_status
+      end
+
+      def machine_config_ssh
+        @machine.config.winssh
+      end
+
+      def download(from, to=nil)
+        @logger.debug("Downloading: #{from} to #{to}")
+
+        sftp_connect do |sftp|
+          sftp.download!(from, to)
+        end
+      end
+
+      # Note: I could not get Net::SFTP to throw a permissions denied error,
+      # even when uploading to a directory where I did not have write
+      # privileges. I believe this is because Windows SSH sessions are started
+      # in an elevated process.
+      def upload(from, to)
+        to = Vagrant::Util::Platform.unix_windows_path(to)
+        @logger.debug("Uploading: #{from} to #{to}")
+
+        if File.directory?(from)
+          if from.end_with?(".")
+            @logger.debug("Uploading directory contents of: #{from}")
+            from = from.sub(/\.$/, "")
+          else
+            @logger.debug("Uploading full directory container of: #{from}")
+            to = File.join(to, File.basename(File.expand_path(from)))
+          end
+        end
+
+        sftp_connect do |sftp|
+          uploader = lambda do |path, remote_dest=nil|
+            if File.directory?(path)
+              Dir.new(path).each do |entry|
+                next if entry == "." || entry == ".."
+                full_path = File.join(path, entry)
+                dest = File.join(to, path.sub(/^#{Regexp.escape(from)}/, ""))
+                sftp.mkdir(dest)
+                uploader.call(full_path, dest)
+              end
+            else
+              if remote_dest
+                dest = File.join(remote_dest, File.basename(path))
+              else
+                dest = to
+                if to.end_with?(File::SEPARATOR)
+                  dest = File.join(to, File.basename(path))
+                end
+              end
+              @logger.debug("Ensuring remote directory exists for destination upload")
+              sftp.mkdir(File.dirname(dest))
+              @logger.debug("Uploading file #{path} to remote #{dest}")
+              upload_file = File.open(path, "rb")
+              begin
+                sftp.upload!(upload_file, dest)
+              ensure
+                upload_file.close
+              end
+            end
+          end
+          uploader.call(from)
+        end
+      end
+
+      # Opens an SFTP connection and yields it so that you can download and
+      # upload files. SFTP works more reliably than SCP on Windows due to
+      # issues with shell quoting and escaping.
+      def sftp_connect
+        # Connect to SFTP and yield the SFTP object
+        connect do |connection|
+          return yield connection.sftp
+        end
+      end
+
+      protected
+
+      # The WinSSH communicator connection provides isolated modification
+      # to the generated connection instances. This modification forces
+      # all provided commands to run within powershell
+      def connect(**opts)
+        connection = nil
+        super { |c| connection = c }
+
+        if !connection.instance_variable_get(:@winssh_patched)
+          open_chan = connection.method(:open_channel)
+          connection.define_singleton_method(:open_channel) do |*args, &chan_block|
+            open_chan.call(*args) do |ch|
+              exec = ch.method(:exec)
+              ch.define_singleton_method(:exec) do |command, &block|
+                command = Base64.strict_encode64(command.encode("UTF-16LE", "UTF-8"))
+                command = "powershell -NoLogo -NonInteractive -ExecutionPolicy Bypass " \
+                  "-NoProfile -EncodedCommand #{command}"
+                exec.call(command, &block)
+              end
+              chan_block.call(ch)
+            end
+          end
+          connection.instance_variable_set(:@winssh_patched, true)
+        end
+
+        if block_given?
+          yield connection
+        else
+          connection
+        end
+      end
+    end
+  end
+end

data/plugins/communicators/winssh/config.rb

@@ -0,0 +1,37 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require File.expand_path("../../../kernel_v2/config/ssh", __FILE__)
+
+module VagrantPlugins
+  module CommunicatorWinSSH
+    class Config < VagrantPlugins::Kernel_V2::SSHConfig
+
+      attr_accessor :upload_directory
+
+      def initialize
+        super
+        @upload_directory = UNSET_VALUE
+      end
+
+      def finalize!
+        @shell = "powershell" if @shell == UNSET_VALUE
+        @sudo_command = "%c" if @sudo_command == UNSET_VALUE
+        @upload_directory = "C:/Windows/Temp" if @upload_directory == UNSET_VALUE
+        if @export_command_template == UNSET_VALUE
+          @export_command_template = '$env:%ENV_KEY%="%ENV_VALUE%"'
+        end
+        super
+      end
+
+      def to_s
+        "WINSSH"
+      end
+
+      # Remove configuration options from regular SSH that are
+      # not used within this communicator
+      undef :forward_x11
+      undef :pty
+    end
+  end
+end

data/plugins/communicators/winssh/plugin.rb

@@ -0,0 +1,24 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module CommunicatorWinSSH
+    class Plugin < Vagrant.plugin("2")
+      name "windows ssh communicator"
+      description <<-DESC
+      DESC
+
+      communicator("winssh") do
+        require File.expand_path("../communicator", __FILE__)
+        Communicator
+      end
+
+      config("winssh") do
+        require_relative "config"
+        Config
+      end
+    end
+  end
+end

data/plugins/guests/alma/cap/flavor.rb

@@ -0,0 +1,26 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestAlma
+    module Cap
+      class Flavor
+        def self.flavor(machine)
+          # Read the version file
+          version = ""
+          machine.communicate.sudo("source /etc/os-release && printf $VERSION_ID") do |type, data|
+            if type == :stdout
+              version = data.split(".").first.to_i
+            end
+          end
+
+          if version.nil? || version < 1
+            :alma
+          else
+            "alma_#{version}".to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/guests/alma/guest.rb

@@ -0,0 +1,13 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require_relative "../linux/guest"
+
+module VagrantPlugins
+  module GuestAlma
+    class Guest < VagrantPlugins::GuestLinux::Guest
+      # Name used for guest detection
+      GUEST_DETECTION_NAME = "almalinux".freeze
+    end
+  end
+end

data/plugins/guests/alma/plugin.rb

@@ -0,0 +1,23 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module GuestAlma
+    class Plugin < Vagrant.plugin("2")
+      name "Alma guest"
+      description "Alma guest support."
+
+      guest(:alma, :redhat) do
+        require_relative "guest"
+        Guest
+      end
+
+      guest_capability(:alma, :flavor) do
+        require_relative "cap/flavor"
+        Cap::Flavor
+      end
+    end
+  end
+end

data/plugins/guests/alpine/cap/change_host_name.rb

@@ -0,0 +1,85 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'vagrant/util/guest_hosts'
+
+module VagrantPlugins
+  module GuestAlpine
+    module Cap
+      class ChangeHostName
+        include Vagrant::Util::GuestHosts::Linux
+
+        def self.change_host_name(machine, name)
+          new(machine, name).change!
+        end
+
+        attr_reader :machine, :new_hostname
+
+        def initialize(machine, new_hostname)
+          @machine = machine
+          @new_hostname = new_hostname
+        end
+
+        def change!
+          update_etc_hosts
+          return unless should_change?
+
+          update_etc_hostname
+          refresh_hostname_service
+          update_mailname
+          renew_dhcp
+        end
+
+        def should_change?
+          new_hostname != current_hostname
+        end
+
+        def current_hostname
+          @current_hostname ||= fetch_current_hostname
+        end
+
+        def fetch_current_hostname
+          hostname = ''
+          machine.communicate.sudo 'hostname -f' do |type, data|
+            hostname = data.chomp if type == :stdout && hostname.empty?
+          end
+
+          hostname
+        end
+
+        def update_etc_hostname
+          machine.communicate.sudo("echo '#{short_hostname}' > /etc/hostname")
+        end
+
+        # /etc/hosts should resemble:
+        # 127.0.0.1   localhost
+        # 127.0.1.1   host.fqdn.com host.fqdn host
+        def update_etc_hosts
+          comm = machine.communicate
+          network_with_hostname = machine.config.vm.networks.map {|_, c| c if c[:hostname] }.compact[0]
+          if network_with_hostname
+            replace_host(comm, new_hostname, network_with_hostname[:ip])
+          else
+            add_hostname_to_loopback_interface(comm, new_hostname)
+          end
+        end
+
+        def refresh_hostname_service
+          machine.communicate.sudo('hostname -F /etc/hostname')
+        end
+
+        def update_mailname
+          machine.communicate.sudo('hostname -f > /etc/mailname')
+        end
+
+        def renew_dhcp
+          machine.communicate.sudo('ifdown -a; ifup -a; ifup eth0')
+        end
+
+        def short_hostname
+          new_hostname.split('.').first
+        end
+      end
+    end
+  end
+end

data/plugins/guests/alpine/cap/configure_networks.rb

@@ -0,0 +1,67 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Style/BracesAroundHashParameters
+#
+# FIXME: address disabled warnings
+#
+require 'set'
+require 'tempfile'
+require 'pathname'
+require 'vagrant/util/template_renderer'
+
+module VagrantPlugins
+  module GuestAlpine
+    module Cap
+      class ConfigureNetworks
+        include Vagrant::Util
+        def self.configure_networks(machine, networks)
+          machine.communicate.tap do |comm|
+            # First, remove any previous network modifications
+            # from the interface file.
+            comm.sudo("sed -e '/^#VAGRANT-BEGIN/,$ d' /etc/network/interfaces > /tmp/vagrant-network-interfaces.pre")
+            comm.sudo("sed -ne '/^#VAGRANT-END/,$ p' /etc/network/interfaces | tail -n +2 > /tmp/vagrant-network-interfaces.post")
+
+            # Accumulate the configurations to add to the interfaces file as
+            # well as what interfaces we're actually configuring since we use that
+            # later.
+            interfaces = Set.new
+            entries = []
+            networks.each do |network|
+              interfaces.add(network[:interface])
+              entry = TemplateRenderer.render("guests/alpine/network_#{network[:type]}", { options: network })
+              entries << entry
+            end
+
+            # Perform the careful dance necessary to reconfigure
+            # the network interfaces
+            temp = Tempfile.new('vagrant')
+            temp.binmode
+            temp.write(entries.join("\n"))
+            temp.close
+
+            comm.upload(temp.path, '/tmp/vagrant-network-entry')
+
+            # Bring down all the interfaces we're reconfiguring. By bringing down
+            # each specifically, we avoid reconfiguring eth0 (the NAT interface) so
+            # SSH never dies.
+            interfaces.each do |interface|
+              comm.sudo("if [[ $(/sbin/ip a show eth#{interface} | grep UP) ]]; then /sbin/ifdown eth#{interface} 2> /dev/null; fi")
+              comm.sudo("/sbin/ip addr flush dev eth#{interface} 2> /dev/null")
+            end
+
+            comm.sudo('cat /tmp/vagrant-network-interfaces.pre /tmp/vagrant-network-entry /tmp/vagrant-network-interfaces.post > /etc/network/interfaces')
+            comm.sudo('rm -f /tmp/vagrant-network-interfaces.pre /tmp/vagrant-network-entry /tmp/vagrant-network-interfaces.post')
+
+            # Bring back up each network interface, reconfigured
+            interfaces.each do |interface|
+              comm.sudo("/sbin/ifup eth#{interface}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/guests/alpine/cap/halt.rb

@@ -0,0 +1,24 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+# rubocop:disable Style/RedundantBegin
+# rubocop:disable Lint/HandleExceptions
+#
+# FIXME: address disabled warnings
+#
+module VagrantPlugins
+  module GuestAlpine
+    module Cap
+      class Halt
+        def self.halt(machine)
+          begin
+            machine.communicate.sudo('poweroff')
+          rescue Net::SSH::Disconnect, IOError
+            # Ignore, this probably means connection closed because it
+            # shut down and SSHd was stopped.
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/guests/alpine/cap/nfs_client.rb

@@ -0,0 +1,17 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+    module GuestAlpine
+        module Cap
+            class NFSClient
+                def self.nfs_client_install(machine)
+                    machine.communicate.sudo('apk update')
+                    machine.communicate.sudo('apk add --upgrade nfs-utils')
+                    machine.communicate.sudo('rc-update add rpc.statd')
+                    machine.communicate.sudo('rc-service rpc.statd start')
+                end
+            end
+        end
+    end
+end

data/plugins/guests/alpine/cap/rsync.rb

@@ -0,0 +1,20 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestAlpine
+    module Cap
+      class RSync
+        def self.rsync_installed(machine)
+          machine.communicate.test('test -f /usr/bin/rsync')
+        end
+
+        def self.rsync_install(machine)
+          machine.communicate.tap do |comm|
+            comm.sudo('apk add --update-cache rsync')
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/guests/alpine/cap/smb.rb

@@ -0,0 +1,16 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module GuestAlpine
+    module Cap
+      class SMB
+        def self.smb_install(machine)
+          machine.communicate.tap do |comm|
+            comm.sudo('apk add cifs-utils')
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/guests/alpine/guest.rb

@@ -0,0 +1,14 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'vagrant'
+
+module VagrantPlugins
+  module GuestAlpine
+    class Guest < Vagrant.plugin('2', :guest)
+      def detect?(machine)
+        machine.communicate.test('cat /etc/alpine-release')
+      end
+    end
+  end
+end