vagrant 1.5.0 → 2.4.4

data/plugins/synced_folders/rsync/helper.rb

@@ -0,0 +1,296 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "fileutils"
+require "ipaddr"
+require "shellwords"
+require "tmpdir"
+
+require "vagrant/util/platform"
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module SyncedFolderRSync
+    # This is a helper that abstracts out the functionality of rsyncing
+    # folders so that it can be called from anywhere.
+    class RsyncHelper
+      # rsync version requirement to support chown argument
+      RSYNC_CHOWN_REQUIREMENT = Gem::Requirement.new(">= 3.1.0").freeze
+
+      # This converts an rsync exclude pattern to a regular expression
+      # we can send to Listen.
+      #
+      # Note: Listen expects a path relative to the parameter passed into the
+      # Listener, not a fully qualified path
+      #
+      # @param [String]  - exclude path
+      # @return [Regexp] - A regex of the path, modified, to exclude
+      def self.exclude_to_regexp(exclude)
+        start_anchor = false
+
+        if exclude.start_with?("/")
+          start_anchor = true
+        end
+
+        exclude = "#{exclude}/" if !exclude.end_with?("/") if start_anchor
+        exclude = "^#{exclude}" if start_anchor
+        exclude += ".*" if (!start_anchor && !exclude.end_with?("*"))
+
+        # This is not an ideal solution, but it's a start. We can improve and
+        # keep unit tests passing in the future.
+        exclude = exclude.gsub("**", "|||GLOBAL|||")
+        exclude = exclude.gsub("|||GLOBAL|||", ".*")
+
+        Regexp.new(exclude)
+      end
+
+      def self.rsync_single(machine, ssh_info, opts)
+        # Folder info
+        guestpath = opts[:guestpath]
+        hostpath  = opts[:hostpath]
+        hostpath  = File.expand_path(hostpath, machine.env.root_path)
+        hostpath  = Vagrant::Util::Platform.fs_real_path(hostpath).to_s
+
+        # if the guest has a guest path scrubber capability, use it
+        if machine.guest.capability?(:rsync_scrub_guestpath)
+          guestpath = machine.guest.capability(:rsync_scrub_guestpath, opts)
+        end
+
+        # Shellescape
+        guestpath = Shellwords.escape(guestpath)
+
+        if Vagrant::Util::Platform.windows?
+          # rsync for Windows expects cygwin style paths, always.
+          hostpath = Vagrant::Util::Platform.cygwin_path(hostpath)
+        end
+
+        # Make sure the host path ends with a "/" to avoid creating
+        # a nested directory...
+        if !hostpath.end_with?("/")
+          hostpath += "/"
+        end
+
+        # Folder options
+        opts[:owner] ||= ssh_info[:username]
+        opts[:group] ||= ssh_info[:username]
+
+        # set log level
+        log_level = ssh_info[:log_level] || "FATAL"
+
+        # Connection information
+        # make it better match lib/vagrant/util/ssh.rb command_options style and logic
+        username = ssh_info[:username]
+        host     = ssh_info[:host]
+        proxy_command = ""
+        if ssh_info[:proxy_command]
+          proxy_command = "-o ProxyCommand='#{ssh_info[:proxy_command]}' "
+        end
+
+        ssh_config_file = ""
+        if ssh_info[:config]
+          ssh_config_file = "-F #{ssh_info[:config]}"
+        end
+
+        # Create the path for the control sockets. We used to do this
+        # in the machine data dir but this can result in paths that are
+        # too long for unix domain sockets.
+        control_options = ""
+        unless Vagrant::Util::Platform.windows?
+          controlpath = Dir.mktmpdir("vagrant-rsync-")
+          control_options = "-o ControlMaster=auto -o ControlPath=#{controlpath} -o ControlPersist=10m "
+        end
+
+        # rsh cmd option
+        rsh = [
+          "ssh", "-p", "#{ssh_info[:port]}",
+          "-o", "LogLevel=#{log_level}",
+          proxy_command,
+          ssh_config_file,
+          control_options,
+        ]
+        rsh += ssh_info[:extra_args] if ssh_info[:extra_args]
+
+        # Solaris/OpenSolaris/Illumos uses SunSSH which doesn't support the
+        # IdentitiesOnly option. Also, we don't enable it if keys_only is false
+        # so that SSH properly searches our identities and tries to do it itself.
+        if !Vagrant::Util::Platform.solaris? && ssh_info[:keys_only]
+          rsh += ["-o", "IdentitiesOnly=yes"]
+        end
+
+        # no strict hostkey checking unless paranoid
+        if ssh_info[:verify_host_key] == :never || !ssh_info[:verify_host_key]
+          rsh += [
+            "-o", "StrictHostKeyChecking=no",
+            "-o", "UserKnownHostsFile=/dev/null"]
+        end
+
+        # If specified, attach the private key paths.
+        if ssh_info[:private_key_path]
+          rsh += ssh_info[:private_key_path].map { |p| "-i '#{p}'" }
+        end
+
+        # Exclude some files by default, and any that might be configured
+        # by the user.
+        excludes = ['.vagrant/']
+        excludes += Array(opts[:exclude]).map(&:to_s) if opts[:exclude]
+        excludes.uniq!
+
+        # Get the command-line arguments
+        args = nil
+        args = Array(opts[:args]).dup if opts[:args]
+        args ||= ["--verbose", "--archive", "--delete", "-z", "--copy-links"]
+
+        # On Windows, we have to set a default chmod flag to avoid permission issues
+        if Vagrant::Util::Platform.windows? && !args.any? { |arg| arg.start_with?("--chmod=") }
+          # Ensures that all non-masked bits get enabled
+          args << "--chmod=ugo=rwX"
+
+          # Remove the -p option if --archive is enabled (--archive equals -rlptgoD)
+          # otherwise new files will not have the destination-default permissions
+          args << "--no-perms" if args.include?("--archive") || args.include?("-a")
+        end
+
+        if opts[:rsync_ownership] && rsync_chown_support?(machine)
+          # Allow rsync to map ownership
+          args << "--chown=#{opts[:owner]}:#{opts[:group]}"
+          # Notify rsync post capability not to chown
+          opts[:chown] = false
+        else
+          # Disable rsync's owner/group preservation (implied by --archive) unless
+          # specifically requested, since we adjust owner/group to match shared
+          # folder setting ourselves.
+          args << "--no-owner" unless args.include?("--owner") || args.include?("-o")
+          args << "--no-group" unless args.include?("--group") || args.include?("-g")
+        end
+
+        # Tell local rsync how to invoke remote rsync with sudo
+        rsync_path = opts[:rsync_path]
+        if !rsync_path && machine.guest.capability?(:rsync_command)
+          rsync_path = machine.guest.capability(:rsync_command)
+        end
+        if rsync_path
+          args << "--rsync-path"<< rsync_path
+        end
+
+        # If the remote host is an IPv6 address reformat
+        begin
+          if IPAddr.new(host).ipv6?
+            host = "[#{host}]"
+          end
+        rescue IPAddr::Error
+          # Ignore
+        end
+
+        # Build up the actual command to execute
+        command = [
+          "rsync",
+          args,
+          "-e", rsh.flatten.join(" "),
+          excludes.map { |e| ["--exclude", e] },
+          hostpath,
+          "#{username}@#{host}:#{guestpath}",
+        ].flatten
+
+        # The working directory should be the root path
+        command_opts = {}
+        command_opts[:workdir] = machine.env.root_path.to_s
+
+        machine.ui.info(I18n.t(
+          "vagrant.rsync_folder", guestpath: guestpath, hostpath: hostpath))
+        if excludes.length > 1
+          machine.ui.info(I18n.t(
+            "vagrant.rsync_folder_excludes", excludes: excludes.inspect))
+        end
+        if opts.include?(:verbose)
+          machine.ui.info(I18n.t("vagrant.rsync_showing_output"));
+        end
+
+        # If we have tasks to do before rsyncing, do those.
+        if machine.guest.capability?(:rsync_pre)
+          machine.guest.capability(:rsync_pre, opts)
+        end
+
+        if opts.include?(:verbose)
+          command_opts[:notify] = [:stdout, :stderr]
+          r = Vagrant::Util::Subprocess.execute(*(command + [command_opts])) {
+            |io_name,data| data.each_line { |line|
+              machine.ui.info("rsync[#{io_name}] -> #{line}") }
+          }
+        else
+          r = Vagrant::Util::Subprocess.execute(*(command + [command_opts]))
+        end
+
+        if r.exit_code != 0
+          raise Vagrant::Errors::RSyncError,
+            command: command.map(&:inspect).join(" "),
+            guestpath: guestpath,
+            hostpath: hostpath,
+            stderr: r.stderr
+        end
+
+        # If we have tasks to do after rsyncing, do those.
+        if machine.guest.capability?(:rsync_post)
+          begin
+            machine.guest.capability(:rsync_post, opts)
+          rescue Vagrant::Errors::VagrantError => err
+            raise Vagrant::Errors::RSyncPostCommandError,
+              guestpath: guestpath,
+              hostpath: hostpath,
+              message: err.to_s
+          end
+        end
+      ensure
+        FileUtils.remove_entry_secure(controlpath, true) if controlpath
+      end
+
+      # Check if rsync versions support using chown option
+      #
+      # @param [Vagrant::Machine] machine The remote machine
+      # @return [Boolean]
+      def self.rsync_chown_support?(machine)
+        if !RSYNC_CHOWN_REQUIREMENT.satisfied_by?(Gem::Version.new(local_rsync_version))
+          return false
+        end
+        mrv = machine_rsync_version(machine)
+        if mrv && !RSYNC_CHOWN_REQUIREMENT.satisfied_by?(Gem::Version.new(mrv))
+          return false
+        end
+        true
+      end
+
+      # @return [String, nil] version of remote rsync
+      def self.machine_rsync_version(machine)
+        if machine.guest.capability?(:rsync_command)
+          rsync_path = machine.guest.capability(:rsync_command)
+        else
+          rsync_path = "rsync"
+        end
+        output = ""
+        machine.communicate.execute(rsync_path + " --version") { |_, data| output << data }
+        vmatch = output.match(/version\s+(?<version>[\d.]+)\s/)
+        if vmatch
+          vmatch[:version]
+        end
+      end
+
+      # @return [String, nil] version of local rsync
+      def self.local_rsync_version
+        if !@_rsync_version
+          r = Vagrant::Util::Subprocess.execute("rsync", "--version")
+          vmatch = r.stdout.to_s.match(/version\s+(?<version>[\d.]+)\s/)
+          if vmatch
+            @_rsync_version = vmatch[:version]
+          end
+        end
+        @_rsync_version
+      end
+
+      # @private
+      # Reset the cached values for helper. This is not considered a public
+      # API and should only be used for testing.
+      def self.reset!
+        instance_variables.each(&method(:remove_instance_variable))
+      end
+    end
+  end
+end

data/plugins/synced_folders/rsync/plugin.rb

@@ -0,0 +1,31 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module SyncedFolderRSync
+    # This plugin implements synced folders via rsync.
+    class Plugin < Vagrant.plugin("2")
+      name "RSync synced folders"
+      description <<-EOF
+      The Rsync synced folder plugin will sync folders via rsync.
+      EOF
+
+      command("rsync", primary: false) do
+        require_relative "command/rsync"
+        Command::Rsync
+      end
+
+      command("rsync-auto", primary: false) do
+        require_relative "command/rsync_auto"
+        Command::RsyncAuto
+      end
+
+      synced_folder("rsync", 5) do
+        require_relative "synced_folder"
+        SyncedFolder
+      end
+    end
+  end
+end

data/plugins/synced_folders/rsync/synced_folder.rb

@@ -0,0 +1,62 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+require "vagrant/util/subprocess"
+require "vagrant/util/which"
+
+require_relative "helper"
+
+module VagrantPlugins
+  module SyncedFolderRSync
+    class SyncedFolder < Vagrant.plugin("2", :synced_folder)
+      include Vagrant::Util
+
+      def initialize(*args)
+        super
+
+        @logger = Log4r::Logger.new("vagrant::synced_folders::rsync")
+      end
+
+      def usable?(machine, raise_error=false)
+        rsync_path = Which.which("rsync")
+        return true if rsync_path
+        return false if !raise_error
+        raise Vagrant::Errors::RSyncNotFound
+      end
+
+      def prepare(machine, folders, opts)
+        # Nothing is necessary to do before VM boot.
+      end
+
+      def enable(machine, folders, opts)
+        if machine.guest.capability?(:rsync_installed)
+          installed = machine.guest.capability(:rsync_installed)
+          if !installed
+            can_install = machine.guest.capability?(:rsync_install)
+            raise Vagrant::Errors::RSyncNotInstalledInGuest if !can_install
+            machine.ui.info I18n.t("vagrant.rsync_installing")
+            machine.guest.capability(:rsync_install)
+          end
+        end
+
+        ssh_info = machine.ssh_info
+
+        if ssh_info[:private_key_path].empty? && ssh_info[:password]
+          machine.ui.warn(I18n.t("vagrant.rsync_ssh_password"))
+        end
+
+        folders.each do |id, folder_opts|
+          RsyncHelper.rsync_single(machine, ssh_info, folder_opts)
+        end
+      end
+
+      # Enable rsync synced folders within WSL when in use
+      # on non-DrvFs file systems
+      def self.wsl_allow_non_drvfs?
+        true
+      end
+    end
+  end
+end

data/plugins/synced_folders/smb/cap/default_fstab_modification.rb

@@ -0,0 +1,14 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module SyncedFolderSMB
+    module Cap
+      module DefaultFstabModification
+        def self.default_fstab_modification(machine)
+          return false
+        end
+      end
+    end
+  end
+end

data/plugins/synced_folders/smb/cap/mount_options.rb

@@ -0,0 +1,59 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require_relative "../../unix_mount_helpers"
+
+module VagrantPlugins
+  module SyncedFolderSMB
+    module Cap
+      module MountOptions
+        extend VagrantPlugins::SyncedFolder::UnixMountHelpers
+
+        MOUNT_TYPE = "cifs".freeze
+
+        # Returns mount options for a smb synced folder
+        #
+        # @param [Machine] machine
+        # @param [String] name of mount
+        # @param [String] path of mount on guest
+        # @param [Hash] hash of mount options 
+        def self.mount_options(machine, name, guest_path, options)
+          mount_options = options.fetch(:mount_options, [])
+          options[:smb_id] ||= name
+          detected_ids = detect_owner_group_ids(machine, guest_path, mount_options, options)
+          mount_uid = detected_ids[:uid]
+          mount_gid = detected_ids[:gid]
+
+          mnt_opts = []
+          if machine.env.host.capability?(:smb_mount_options)
+            mnt_opts += machine.env.host.capability(:smb_mount_options)
+          else
+            mnt_opts << "sec=ntlmssp"
+          end
+
+          mnt_opts << "credentials=/etc/smb_creds_#{options[:smb_id]}"
+          mnt_opts << "uid=#{mount_uid}"
+          mnt_opts << "gid=#{mount_gid}"
+          if !ENV['VAGRANT_DISABLE_SMBMFSYMLINKS']
+            mnt_opts << "mfsymlinks"
+          end
+          mnt_opts << "_netdev"
+          mnt_opts = merge_mount_options(mnt_opts, options[:mount_options] || [])
+          mount_options = mnt_opts.join(",")
+          return mount_options, mount_uid, mount_gid
+        end
+
+        def self.mount_type(machine)
+          return  MOUNT_TYPE
+        end
+
+        def self.mount_name(machine, name, data)
+          candidate_ips = machine.env.host.capability(:configured_ip_addresses)
+          data[:smb_host] ||= machine.guest.capability(
+            :choose_addressable_ip_addr, candidate_ips)
+          "//#{data[:smb_host]}/#{data[:smb_id]}"
+        end
+      end
+    end
+  end
+end

data/plugins/synced_folders/smb/config.rb

@@ -0,0 +1,26 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module SyncedFolderSMB
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :functional
+
+      def initialize
+        super
+
+        @functional = UNSET_VALUE
+      end
+
+      def finalize!
+        @functional = true if @functional == UNSET_VALUE
+      end
+
+      def to_s
+        "SMB"
+      end
+    end
+  end
+end

data/plugins/synced_folders/smb/errors.rb

@@ -0,0 +1,65 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module SyncedFolderSMB
+    module Errors
+      # A convenient superclass for all our errors.
+      class SMBError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_sf_smb.errors")
+      end
+
+      class SMBNotSupported < SMBError
+        error_key(:not_supported)
+      end
+
+      class SMBStartFailed < SMBError
+        error_key(:start_failed)
+      end
+
+      class SMBCredentialsMissing < SMBError
+        error_key(:credentials_missing)
+      end
+
+      class SMBListFailed < SMBError
+        error_key(:list_failed)
+      end
+
+      class SMBNameError < SMBError
+        error_key(:name_error)
+      end
+
+      class CredentialsRequestError < SMBError
+        error_key(:credentials_request_error)
+      end
+
+      class DefineShareFailed < SMBError
+        error_key(:define_share_failed)
+      end
+
+      class PruneShareFailed < SMBError
+        error_key(:prune_share_failed)
+      end
+
+      class NoHostIPAddr < SMBError
+        error_key(:no_routable_host_addr)
+      end
+
+      class PowershellError < SMBError
+        error_key(:powershell_error)
+      end
+
+      class PowershellVersion < SMBError
+        error_key(:powershell_version)
+      end
+
+      class WindowsHostRequired < SMBError
+        error_key(:windows_host_required)
+      end
+
+      class WindowsAdminRequired < SMBError
+        error_key(:windows_admin_required)
+      end
+    end
+  end
+end

data/plugins/synced_folders/smb/plugin.rb

@@ -0,0 +1,60 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module SyncedFolderSMB
+    autoload :Errors, File.expand_path("../errors", __FILE__)
+
+    # This plugin implements SMB synced folders.
+    class Plugin < Vagrant.plugin("2")
+      name "SMB synced folders"
+      description <<-EOF
+      The SMB synced folders plugin enables you to use SMB folders on
+      Windows or macOS and share them to guest machines.
+      EOF
+
+      config("smb") do
+        require_relative "config"
+        Config
+      end
+
+      synced_folder("smb", 7) do
+        require_relative "synced_folder"
+        init!
+        SyncedFolder
+      end
+
+      synced_folder_capability("smb", "default_fstab_modification") do
+        require_relative "cap/default_fstab_modification"
+        Cap::DefaultFstabModification
+      end
+
+      synced_folder_capability("smb", "mount_options") do
+        require_relative "cap/mount_options"
+        Cap::MountOptions
+      end
+
+      synced_folder_capability("smb", "mount_name") do
+        require_relative "cap/mount_options"
+        Cap::MountOptions
+      end
+
+      synced_folder_capability("smb", "mount_type") do
+        require_relative "cap/mount_options"
+        Cap::MountOptions
+      end
+
+      protected
+
+      def self.init!
+        return if defined?(@_init)
+        I18n.load_path << File.expand_path(
+          "templates/locales/synced_folder_smb.yml", Vagrant.source_root)
+        I18n.reload!
+        @_init = true
+      end
+    end
+  end
+end