vagrant-parallels 2.1.0 → 2.2.3

data/lib/vagrant-parallels/errors.rb

@@ -27,10 +27,6 @@ module VagrantPlugins
         error_key(:json_parse_error)
       end
 
-      class LinuxMountFailed < VagrantParallelsError
-        error_key(:linux_mount_failed)
-      end
-
       class LinuxPrlFsInvalidOptions < VagrantParallelsError
         error_key(:linux_prl_fs_invalid_options)
       end
@@ -59,6 +55,10 @@ module VagrantPlugins
         error_key(:parallels_invalid_version)
       end
 
+      class ParallelsMountFailed < VagrantParallelsError
+        error_key(:parallels_mount_failed)
+      end
+
       class ParallelsNotDetected < VagrantParallelsError
         error_key(:parallels_not_detected)
       end

data/lib/vagrant-parallels/guest_cap/linux/mount_parallels_shared_folder.rb

@@ -1,7 +1,19 @@
+require 'shellwords'
+
+require_relative "../../util/unix_mount_helpers"
+
 module VagrantPlugins
   module Parallels
     module GuestLinuxCap
       class MountParallelsSharedFolder
+        extend VagrantPlugins::Parallels::Util::UnixMountHelpers
+
+        # Mounts Parallels Desktop shared folder on linux guest
+        #
+        # @param [Machine] machine
+        # @param [String] name of mount
+        # @param [String] path of mount on guest
+        # @param [Hash] hash of mount options
         def self.mount_parallels_shared_folder(machine, name, guestpath, options)
           # Sanity check for mount options: we are not supporting
           # VirtualBox-specific 'fmode' and 'dmode' options
@@ -15,83 +27,38 @@ module VagrantPlugins
             end
           end
 
-          expanded_guest_path = machine.guest.capability(
-            :shell_expand_guest_path, guestpath)
+          guest_path = Shellwords.escape(guestpath)
+          mount_type = options[:plugin].capability(:mount_type)
 
-          mount_commands = []
+          @@logger.debug("Mounting #{name} (#{options[:hostpath]} to #{guestpath})")
 
-          if options[:owner].is_a? Integer
-            mount_uid = options[:owner]
-          else
-            mount_uid = "`id -u #{options[:owner]}`"
-          end
-
-          if options[:group].is_a? Integer
-            mount_gid = options[:group]
-            mount_gid_old = options[:group]
-          else
-            mount_gid = "`getent group #{options[:group]} | cut -d: -f3`"
-            mount_gid_old = "`id -g #{options[:group]}`"
-          end
-
-          # First mount command uses getent to get the group
-          mount_options = "-o uid=#{mount_uid},gid=#{mount_gid}"
-          mount_options += ",#{options[:mount_options].join(',')}" if options[:mount_options]
-          mount_commands << "mount -t prl_fs #{mount_options} #{name} #{expanded_guest_path}"
-
-          # Second mount command uses the old style `id -g`
-          mount_options = "-o uid=#{mount_uid},gid=#{mount_gid_old}"
-          mount_options += ",#{options[:mount_options].join(',')}" if options[:mount_options]
-          mount_commands << "mount -t prl_fs #{mount_options} #{name} #{expanded_guest_path}"
-
-          # Clear prior symlink if exists
-          if machine.communicate.test("test -L #{expanded_guest_path}")
-            machine.communicate.sudo("rm #{expanded_guest_path}")
-          end
+          mount_options, mount_uid, mount_gid = options[:plugin].capability(:mount_options, name, guest_path, options)
+          mount_command = "mount -t #{mount_type} -o #{mount_options} #{name} #{guest_path}"
 
           # Create the guest path if it doesn't exist
-          machine.communicate.sudo("mkdir -p #{expanded_guest_path}")
+          machine.communicate.sudo("mkdir -p #{guest_path}")
 
           # Attempt to mount the folder. We retry here a few times because
           # it can fail early on.
-          attempts = 0
-          while true
-            success = true
-
-            mount_commands.each do |command|
-              no_such_device = false
-              status = machine.communicate.sudo(command, error_check: false) do |type, data|
-                no_such_device = true if type == :stderr && data =~ /No such device/i
-              end
-
-              success = status == 0 && !no_such_device
-              break if success
-            end
-
-            break if success
-
-            attempts += 1
-            if attempts > 10
-              raise VagrantPlugins::Parallels::Errors::LinuxMountFailed,
-                command: mount_commands.join("\n")
-            end
-
-            sleep 2
+          stderr = ""
+          retryable(on: Errors::ParallelsMountFailed, tries: 3, sleep: 5) do
+            machine.communicate.sudo(mount_command,
+              error_class: Errors::ParallelsMountFailed,
+              error_key: :parallels_mount_failed,
+              command: mount_command,
+              output: stderr,
+            ) { |type, data| stderr = data if type == :stderr }
           end
 
-          # Emit an upstart event if we can
-          machine.communicate.sudo <<-EOH.gsub(/^ {10}/, "")
-            if command -v /sbin/init && /sbin/init 2>/dev/null --version | grep upstart; then
-              /sbin/initctl emit --no-wait vagrant-mounted MOUNTPOINT=#{expanded_guest_path}
-            fi
-          EOH
+          emit_upstart_notification(machine, guest_path)
         end
 
         def self.unmount_parallels_shared_folder(machine, guestpath, options)
-          result = machine.communicate.sudo(
-            "umount #{guestpath}", error_check: false)
+          guest_path = Shellwords.escape(guestpath)
+
+          result = machine.communicate.sudo("umount #{guest_path}", error_check: false)
           if result == 0
-            machine.communicate.sudo("rmdir #{guestpath}", error_check: false)
+            machine.communicate.sudo("rmdir #{guest_path}", error_check: false)
           end
         end
 

data/lib/vagrant-parallels/model/forwarded_port.rb

@@ -29,14 +29,26 @@ module VagrantPlugins
         # @return [Integer]
         attr_reader :host_port
 
-        def initialize(id, host_port, guest_port, options)
+        # The ip of the guest to be used for the port.
+        #
+        # @return [String]
+        attr_reader :guest_ip
+
+        # The ip of the host used to access the port.
+        #
+        # @return [String]
+        attr_reader :host_ip
+
+        def initialize(id, host_port, guest_port, host_ip, guest_ip, **options)
           @id         = id
           @guest_port = guest_port
+          @guest_ip   = guest_ip
           @host_port  = host_port
+          @host_ip    = host_ip
 
           options ||= {}
           @auto_correct = false
-          @auto_correct = options[:auto_correct] if options.has_key?(:auto_correct)
+          @auto_correct = options[:auto_correct] if options.key?(:auto_correct)
           @protocol = options[:protocol] || 'tcp'
         end
 

data/lib/vagrant-parallels/plugin.rb

@@ -103,6 +103,21 @@ module VagrantPlugins
         SyncedFolder
       end
 
+      synced_folder_capability(:parallels, "mount_name") do
+        require_relative "cap/mount_options"
+        SyncedFolderCap::MountOptions
+      end
+
+      synced_folder_capability(:parallels, "mount_options") do
+        require_relative "cap/mount_options"
+        SyncedFolderCap::MountOptions
+      end
+
+      synced_folder_capability(:parallels, "mount_type") do
+        require_relative "cap/mount_options"
+        SyncedFolderCap::MountOptions
+      end
+
       # This initializes the internationalization strings.
       def self.setup_i18n
         I18n.load_path << File.expand_path('locales/en.yml', Parallels.source_root)

data/lib/vagrant-parallels/synced_folder.rb

@@ -9,8 +9,8 @@ module VagrantPlugins
           machine.provider_config.functional_psf
       end
 
-      def enable(machine, folders, _opts)
-        # Export the shared folders to the VM
+      def prepare(machine, folders, _opts)
+        # Setup shared folder definitions in the VM config.
         defs = []
         folders.each do |id, data|
           hostpath = data[:hostpath]
@@ -19,16 +19,15 @@ module VagrantPlugins
           end
 
           defs << {
-            name: os_friendly_id(id),
+            name: data[:plugin].capability(:mount_name, id, data),
             hostpath: hostpath.to_s,
           }
         end
 
-        # We should prepare only folders with unique hostpath values.
-        # Anyway, duplicates will be mounted later.
-        defs.uniq! { |d| d[:hostpath] }
         driver(machine).share_folders(defs)
+      end
 
+      def enable(machine, folders, _opts)
         # short guestpaths first, so we don't step on ourselves
         folders = folders.sort_by do |id, data|
           if data[:guestpath]
@@ -39,8 +38,6 @@ module VagrantPlugins
           end
         end
 
-        shf_config = driver(machine).read_shared_folders
-
         # Parallels Shared Folder services can override Vagrant synced folder
         # configuration. These services should be pre-configured.
         if machine.guest.capability?(:prepare_psf_services)
@@ -49,12 +46,8 @@ module VagrantPlugins
 
         # Go through each folder and mount
         machine.ui.output(I18n.t('vagrant.actions.vm.share_folders.mounting'))
-        folders.each do |_ , data|
-          # Parallels specific: get id from the VM setting
-          # It allows to mount one host folder more then one time [GH-105]
-          id = shf_config.key(data[:hostpath])
-
-          if data[:guestpath] and id
+        folders.each do |id , data|
+          if data[:guestpath]
             # Guest path specified, so mount the folder to specified point
             machine.ui.detail(I18n.t('vagrant.actions.vm.share_folders.mounting_entry',
                                      guestpath: data[:guestpath],
@@ -70,7 +63,11 @@ module VagrantPlugins
 
             # Mount the actual folder
             machine.guest.capability(
-                :mount_parallels_shared_folder, id, data[:guestpath], data)
+              :mount_parallels_shared_folder,
+              data[:plugin].capability(:mount_name, id, data),
+              data[:guestpath],
+              data
+            )
           else
             # If no guest path is specified, then automounting is disabled
             machine.ui.detail(I18n.t('vagrant.actions.vm.share_folders.nomount_entry',
@@ -89,7 +86,7 @@ module VagrantPlugins
         end
 
         # Remove the shared folders from the VM metadata
-        names = folders.map { |id, _data| os_friendly_id(id) }
+        names = folders.map { |id, data| data[:plugin].capability(:mount_name, id, data) }
         driver(machine).unshare_folders(names)
       end
 
@@ -103,11 +100,6 @@ module VagrantPlugins
       def driver(machine)
         machine.provider.driver
       end
-
-      def os_friendly_id(id)
-        # Replace chars *, ", :, <, >, ?, |, /, \
-        id.gsub(/[*":<>?|\/\\]/,'_').sub(/^_/, '')
-      end
     end
   end
 end

data/lib/vagrant-parallels/util/compile_forwarded_ports.rb

@@ -12,23 +12,25 @@ module VagrantPlugins
           mappings = {}
 
           config.vm.networks.each do |type, options|
-            if type == :forwarded_port
-              guest_port = options[:guest]
-              host_port  = options[:host]
-              protocol   = options[:protocol] || 'tcp'
-              options    = scoped_hash_override(options, :parallels)
-              id         = options[:id]
-
-              # If the forwarded port was marked as disabled, ignore.
-              next if options[:disabled]
-
-              # Temporary disable automatically pre-configured forwarded ports
-              # for SSH, since it is working not so well [GH-146]
-              next if id == 'ssh'
-
-              mappings[host_port.to_s + protocol.to_s] =
-                Model::ForwardedPort.new(id, host_port, guest_port, options)
-            end
+            next unless type == :forwarded_port
+
+            guest_port = options[:guest]
+            guest_ip   = options[:guest_ip]
+            host_port  = options[:host]
+            host_ip    = options[:host_ip]
+            protocol   = options[:protocol] || 'tcp'
+            options    = scoped_hash_override(options, :parallels)
+            id         = options[:id]
+
+            # If the forwarded port was marked as disabled, ignore.
+            next if options[:disabled]
+
+            # Temporary disable automatically pre-configured forwarded ports
+            # for SSH, since it is working not so well [GH-146]
+            next if id == 'ssh'
+
+            mappings[host_port.to_s + protocol.to_s] =
+              Model::ForwardedPort.new(id, host_port, guest_port, host_ip, guest_ip, **options)
           end
 
           mappings.values

data/lib/vagrant-parallels/util/unix_mount_helpers.rb

@@ -0,0 +1,121 @@
+require "shellwords"
+require "vagrant/util/retryable"
+
+module VagrantPlugins
+  module Parallels
+    module Util
+      module UnixMountHelpers
+
+        def self.extended(klass)
+          if !klass.class_variable_defined?(:@@logger)
+            klass.class_variable_set(:@@logger, Log4r::Logger.new(klass.name.downcase))
+          end
+          klass.extend Vagrant::Util::Retryable
+        end
+
+        def detect_owner_group_ids(machine, guest_path, mount_options, options)
+          mount_uid = find_mount_options_id("uid", mount_options)
+          mount_gid = find_mount_options_id("gid", mount_options)
+
+          if mount_uid.nil?
+            if options[:owner].to_i.to_s == options[:owner].to_s
+              mount_uid = options[:owner]
+              self.class_variable_get(:@@logger).debug("Owner user ID (provided): #{mount_uid}")
+            else
+              output = {stdout: '', stderr: ''}
+              uid_command = "id -u #{options[:owner]}"
+              machine.communicate.execute(uid_command,
+                error_class: Errors::ParallelsMountFailed,
+                error_key: :parallels_mount_failed,
+                command: uid_command,
+                output: output[:stderr]
+              ) { |type, data| output[type] << data if output[type] }
+              mount_uid = output[:stdout].chomp
+              self.class_variable_get(:@@logger).debug("Owner user ID (lookup): #{options[:owner]} -> #{mount_uid}")
+            end
+          else
+            machine.ui.warn "Detected mount owner ID within mount options. (uid: #{mount_uid} guestpath: #{guest_path})"
+          end
+
+          if mount_gid.nil?
+            if options[:group].to_i.to_s == options[:group].to_s
+              mount_gid = options[:group]
+              self.class_variable_get(:@@logger).debug("Owner group ID (provided): #{mount_gid}")
+            else
+              begin
+                output = {stdout: '', stderr: ''}
+                gid_command = "getent group #{options[:group]}"
+                machine.communicate.execute(gid_command,
+                  error_class: Errors::ParallelsMountFailed,
+                  error_key: :parallels_mount_failed,
+                  command: gid_command,
+                  output: output[:stderr]
+                ) { |type, data| output[type] << data if output[type] }
+                mount_gid = output[:stdout].split(':').at(2).to_s.chomp
+                self.class_variable_get(:@@logger).debug("Owner group ID (lookup): #{options[:group]} -> #{mount_gid}")
+              rescue Vagrant::Errors::ParallelsMountFailed
+                if options[:owner] == options[:group]
+                  self.class_variable_get(:@@logger).debug("Failed to locate group `#{options[:group]}`. Group name matches owner. Fetching effective group ID.")
+                  output = {stdout: ''}
+                  result = machine.communicate.execute("id -g #{options[:owner]}",
+                    error_check: false
+                  ) { |type, data| output[type] << data if output[type] }
+                  mount_gid = output[:stdout].chomp if result == 0
+                  self.class_variable_get(:@@logger).debug("Owner group ID (effective): #{mount_gid}")
+                end
+                raise unless mount_gid
+              end
+            end
+          else
+            machine.ui.warn "Detected mount group ID within mount options. (gid: #{mount_gid} guestpath: #{guest_path})"
+          end
+          {:gid => mount_gid, :uid => mount_uid}
+        end
+
+        def find_mount_options_id(id_name, mount_options)
+          id_line = mount_options.detect{|line| line.include?("#{id_name}=")}
+          if id_line
+            match = id_line.match(/,?#{Regexp.escape(id_name)}=(?<option_id>\d+),?/)
+            found_id = match["option_id"]
+            updated_id_line = [
+              match.pre_match,
+              match.post_match
+            ].find_all{|string| !string.empty?}.join(',')
+            if updated_id_line.empty?
+              mount_options.delete(id_line)
+            else
+              idx = mount_options.index(id_line)
+              mount_options.delete(idx)
+              mount_options.insert(idx, updated_id_line)
+            end
+          end
+          found_id
+        end
+
+        def emit_upstart_notification(machine, guest_path)
+          # Emit an upstart event if we can
+          machine.communicate.sudo <<-EOH.gsub(/^ {12}/, "")
+              if command -v /sbin/init && /sbin/init 2>/dev/null --version | grep upstart; then
+                /sbin/initctl emit --no-wait vagrant-mounted MOUNTPOINT=#{guest_path}
+              fi
+            EOH
+        end
+
+        def merge_mount_options(base, overrides)
+          base = base.join(",").split(",")
+          overrides = overrides.join(",").split(",")
+          b_kv = Hash[base.map{|item| item.split("=", 2) }]
+          o_kv = Hash[overrides.map{|item| item.split("=", 2) }]
+          merged = {}.tap do |opts|
+            (b_kv.keys + o_kv.keys).uniq.each do |key|
+              opts[key] = o_kv.fetch(key, b_kv[key])
+            end
+          end
+          merged.map do |key, value|
+            [key, value].compact.join("=")
+          end
+        end
+      end
+    end
+  end
+end