vagrant-vmware-desktop 0.0.1 → 3.0.0

data/lib/vagrant-vmware-desktop/errors.rb

@@ -0,0 +1,342 @@
+require "vagrant"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Errors
+      # This is the base class for all errors within the VMware Fusion
+      # plugin.
+      class Base < Vagrant::Errors::VagrantError
+        error_namespace("hashicorp.vagrant_vmware_desktop.errors")
+
+        def initialize(message=nil, *args)
+          message ||= {}
+          message[:product] = PRODUCT_NAME.capitalize
+
+          super(message, *args)
+        end
+      end
+
+      class FeatureNotSupported < Base
+        error_key(:feature_not_supported)
+      end
+
+      class BoxVMXFileNotFound < Base
+        error_key(:box_vmx_file_not_found)
+      end
+
+      class CannotGetSSHInfo < Base
+        error_key(:cannot_get_ssh_info)
+      end
+
+      class CloneFolderExists < Base
+        error_key(:clone_folder_exists)
+      end
+
+      class CloneFolderNotFolder < Base
+        error_key(:clone_folder_not_folder)
+      end
+
+      class DiskNotCreated < Base
+        error_key(:disk_not_created)
+      end
+
+      class DiskNotResizedSnapshot < Base
+        error_key(:disk_not_resized_snapshot)
+      end
+
+      class MissingNATDevice < Base
+        error_key(:missing_nat_device)
+      end
+
+      class BaseAddressRange < Base
+        error_key(:base_address_range)
+      end
+
+      class DestroyInvalidState < Base
+        error_key(:destroy_invalid_state)
+      end
+
+      class DriverInvalidResponse < Base
+        error_key(:driver_invalid_response)
+      end
+
+      class DriverClonePermissionFailure < Base
+        error_key(:driver_clone_permission_failure)
+      end
+
+      class DriverDHCPLeasesReadPerms < Base
+        error_key(:driver_dhcp_leases_read_perms)
+      end
+
+      class DriverMissingDHCPLeasesFile < Base
+        error_key(:driver_missing_dhcp_leases_file)
+      end
+
+      class DriverMissingFPNatConf < Base
+        error_key(:driver_missing_fp_nat_conf)
+      end
+
+      class DriverMissingNetworkingFile < Base
+        error_key(:driver_missing_networking_file)
+      end
+
+      class DriverMissingServiceStarter < Base
+        error_key(:driver_missing_service_starter)
+      end
+
+      class DriverMissingVMNetCLI < Base
+        error_key(:driver_missing_vmnet_cli)
+      end
+
+      class DriverMissingVMX < Base
+        error_key(:driver_missing_vmx)
+      end
+
+      class DriverMissingVMXCLI < Base
+        error_key(:driver_missing_vmx_cli)
+      end
+
+      class DriverNetworkingFileNotFound < Base
+        error_key(:driver_networking_file_not_found)
+      end
+
+      class DriverNetworkingFileBadPermissions < Base
+        error_key(:driver_networking_file_bad_permissions)
+      end
+
+      class DriverReadVersionFailed < Base
+        error_key(:driver_read_version_failed)
+      end
+
+      class DriverVMNetCommandFailed < Base; end
+
+      class DriverVMNetConfigureFailed < DriverVMNetCommandFailed
+        error_key(:driver_vmnet_configure_failed)
+      end
+
+      class DriverVMNetStartFailed < DriverVMNetCommandFailed
+        error_key(:driver_vmnet_start_failed)
+      end
+
+      class DriverVMNetStopFailed < DriverVMNetCommandFailed
+        error_key(:driver_vmnet_stop_failed)
+      end
+
+      class ForwardedPortsCollideWithExistingNAT < Base
+        error_key(:forwarded_ports_collide_with_existing_nat)
+      end
+
+      class ForwardedPortNoGuestIP < Base
+        error_key(:forwarded_port_no_guest_ip)
+      end
+
+      class FusionUpgradeRequired < Base
+        error_key(:fusion_upgrade_required)
+      end
+
+      class GuestMissingHGFS < Base
+        error_key(:guest_missing_hgfs)
+      end
+
+      class HelperFailed < Base
+        error_key(:helper_failed)
+      end
+
+      class HelperInstallFailed < Base
+        error_key(:helper_install_failed)
+      end
+
+      class HelperInvalidCommand < Base
+        error_key(:helper_invalid_command)
+      end
+
+      class HelperNotRoot < Base
+        error_key(:helper_not_root)
+      end
+
+      class HelperRequiresCommand < Base
+        error_key(:helper_requires_command)
+      end
+
+      class HelperRequiresDataFile < Base
+        error_key(:helper_requires_data_file)
+      end
+
+      class HelperRequiresReinstall < Base
+        error_key(:helper_requires_reinstall)
+      end
+
+      class HelperWrapperMissing < Base
+        error_key(:helper_wrapper_missing)
+      end
+
+      class LinuxMountGIDFailed < Base
+        error_key(:linux_mount_gid_failed)
+      end
+
+      class LinuxMountUIDFailed < Base
+        error_key(:linux_mount_uid_failed)
+      end
+
+      class LinuxServiceInitScriptMissing < Base
+        error_key(:linux_service_init_script_missing)
+      end
+
+      class NetworkingFileMissingVersion < Base
+        error_key(:networking_file_missing_version)
+      end
+
+      class NetworkingFileUnsupportedVersion < Base
+        error_key(:networking_file_unsupported_version)
+      end
+
+      class NetworkingHostOnlyCollision < Base
+        error_key(:networking_host_only_collision)
+      end
+
+      class NetworkingNoSlotsForHighLevel < Base
+        error_key(:networking_no_slots_for_high_level)
+      end
+
+      class NFSNoNetwork < Base
+        error_key(:nfs_no_network)
+      end
+
+      class PackageNotSupported < Base
+        error_key(:package_not_supported)
+      end
+
+      class RoutingTableError < Base; end
+
+      class RoutingTableCommandNotFound < RoutingTableError
+        error_key(:routing_table_command_not_found)
+      end
+
+      class RoutingTableLoadError < RoutingTableError
+        error_key(:routing_table_load_error)
+      end
+
+      class RoutingTableUnsupportedOS < RoutingTableError
+        error_key(:routing_table_unsupported_os)
+      end
+
+      class SharedFolderSymlinkFailed < Base
+        error_key(:shared_folder_symlink_failed)
+      end
+
+      class SingleMachineLock < Base
+        error_key(:single_machine_lock)
+      end
+
+      class StartTimeout < Base
+        error_key(:start_timeout)
+      end
+
+      class UtilityUpgradeRequired < Base
+        error_key(:utility_upgrade_required)
+      end
+
+      class VMNetDeviceCreateFailed < Base
+        error_key(:vmnet_device_create_failed)
+      end
+
+      class VMNetDeviceRouteConflict < Base
+        error_key(:vmnet_device_route_conflict)
+      end
+
+      class VMNetDevicesWontStart < Base
+        error_key(:vmnet_devices_wont_start)
+      end
+
+      class VMNetSlotsFull < Base
+        error_key(:vmnet_slots_full)
+      end
+
+      class VMNetNoIPV6 < Base
+        error_key(:vmnet_no_ipv6)
+      end
+
+      class VMExecError < Base
+        error_key(:vmexec_error)
+      end
+
+      class VMRunError < Base
+        error_key(:vmrun_error)
+      end
+
+      class VMRunNotFound < Base
+        error_key(:vmrun_not_Found)
+      end
+
+      class VMwareLinuxServiceWontStart < Base
+        error_key(:vmware_linux_service_wont_start)
+      end
+
+      class VnetLibError < Base
+        error_key(:vnetlib_error)
+      end
+
+      class VnetLibNotFound < Base
+        error_key(:vnetlib_not_found)
+      end
+
+      class WorkstationUpgradeRequired < Base
+        error_key(:workstation_upgrade_required)
+      end
+
+      ## Driver API
+
+      class DriverAPICertificateError < Base
+        error_key(:driver_api_certificate_error)
+      end
+
+      class DriverAPIKeyError < Base
+        error_key(:driver_api_key_error)
+      end
+
+      class DriverAPIConnectionFailed < Base
+        error_key(:driver_api_connection_failed)
+      end
+
+      class DriverAPIRequestUnexpectedError < Base
+        error_key(:driver_api_request_unexpected_error)
+      end
+
+      class DriverAPIInvalidResponse < Base
+        error_key(:driver_api_invalid_response)
+      end
+
+      class DriverAPIPortForwardListError < Base
+        error_key(:driver_api_port_forward_list_error)
+      end
+
+      class DriverAPIDeviceCreateError < Base
+        error_key(:driver_api_device_create_error)
+      end
+
+      class DriverAPIPortForwardError < Base
+        error_key(:driver_api_port_forward_error)
+      end
+
+      class DriverAPIPortForwardPruneError < Base
+        error_key(:driver_api_port_forward_prune_error)
+      end
+
+      class DriverAPIDeviceListError < Base
+        error_key(:driver_api_device_list_error)
+      end
+
+      class DriverAPIVMwareVersionDetectionError < Base
+        error_key(:driver_api_vmware_version_detection_error)
+      end
+
+      class DriverAPIVMwarePathsDetectionError < Base
+        error_key(:driver_api_vmware_paths_detection_error)
+      end
+
+      class DriverAPIAddressReservationError < Base
+        error_key(:driver_api_address_reservation_error)
+      end
+    end
+  end
+end

data/lib/vagrant-vmware-desktop/guest_cap/linux/mount_vmware_shared_folder.rb

@@ -0,0 +1,158 @@
+module HashiCorp
+  module VagrantVMwareDesktop
+    module GuestCap
+      module Linux
+        class MountVMwareSharedFolder
+          # Root location for vagrant generated vmhgfs mounts
+          VAGRANT_ROOT_MOUNT_POINT = "/mnt/vagrant-mounts".freeze
+
+          def self.mount_vmware_shared_folder(machine, name, guestpath, options)
+            expanded_guest_path = machine.guest.capability(
+              :shell_expand_guest_path, guestpath)
+
+            # Determine if we're using the HGFS kernel module or open-vm-tools.
+            # We prefer to use the kernel module so we test for that.
+            kernel_mod = machine.communicate.test("PATH=\"/sbin:$PATH\" lsmod | grep -i '^vmhgfs'")
+
+            # The user can also override the mount strategy used by specifying a
+            # vmware__mount_strategy option (the prefix is removed by Vagrant core).
+            kernel_mod = options[:mount_strategy].to_s == "kernel" if options[:mount_strategy]
+
+            # NOTE: This is pulled directly from the linux cap within vagrant proper. Once it is properly
+            #   extracted in vagrant, this should just be a method call for consistency.
+            if options[:owner].to_i.to_s == options[:owner].to_s
+              mount_uid = options[:owner]
+            else
+              output = ""
+              uid_command = "id -u #{options[:owner]}"
+              machine.communicate.execute(uid_command, error_check: false) { |type, data|
+                output << data if type == :stdout
+              }
+              mount_uid = output.strip
+              if mount_uid.to_i.to_s != mount_uid
+                raise Errors::LinuxMountUIDFailed,
+                  folder_name: name
+              end
+            end
+
+            if options[:group].to_i.to_s == options[:group].to_s
+              mount_gid = options[:group]
+            else
+              output = ""
+              gid_command = "getent group #{options[:group]}"
+              machine.communicate.execute(gid_command, error_check: false) { |type, data|
+                output << data if type == :stdout
+              }
+              mount_gid = output.strip.split(':').at(2)
+              if mount_gid.to_i.to_s != mount_gid && options[:owner] == options[:group]
+                output = ""
+                result = machine.communicate.execute("id -g #{options[:owner]}", error_check: false) { |type, data|
+                  output << data if type == :stdout
+                }
+                mount_gid = output.strip
+              end
+              if mount_gid.to_i.to_s != mount_gid
+                raise Errors::LinuxMountGIDFailed,
+                  folder_name: name
+              end
+            end
+            uid = mount_uid
+            gid = mount_gid
+
+            # Create the guest path if it doesn't exist
+            machine.communicate.sudo(
+              "test -L #{expanded_guest_path} && rm -rf #{expanded_guest_path}",
+              error_check: false)
+            machine.communicate.sudo("mkdir -p #{expanded_guest_path}")
+
+            # If the kernel module is in use, continue using existing mount strategy. If the
+            # kernel module is not in use, then we can assume the open-vm-tools are in use
+            # which will automatically mount the share into the /mnt/hgfs directory
+            if kernel_mod
+              # Expand the name to the proper VMware name
+              name = ".host:/#{name}"
+
+              # Start building the mount options starting with the basic UID/GID
+              mount_options = "-o uid=#{uid},gid=#{gid}"
+
+              # Options
+              mount_options += ",#{options[:extra]}" if options[:extra]
+              mount_options += ",#{options[:mount_options].join(",")}" if options[:mount_options]
+
+              # Build the full command
+              mount_command = "mount -t vmhgfs"
+              mount_command = "#{mount_command} #{mount_options} '#{name}' '#{expanded_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
+                machine.communicate.sudo(mount_command) do |type, data|
+                  success = false if type == :stderr && data =~ /No such device/i
+
+                  # Sometimes it takes extra time for the `vmhgfs` filesystem
+                  # type to become available for use.
+                  success = false if type == :stderr && data =~ /unknown filesystem type/i
+                end
+
+                break if success
+
+                attempts += 1
+                if attempts > 5
+                  raise Vagrant::Errors::LinuxMountFailed,
+                    command: mount_command
+                end
+                sleep 3
+              end
+            else
+              # If using vmhgfs-fuse mounting the shared folder directly results in invalid
+              # symlink generation. To resolve this we can bind mount the shared folder from
+              # the full host shared mount. The open-vm-tools will automatically mount in
+              # /mnt/hgfs, but the biggest issue with this mount is that it is fully accessible
+              # to all users. Instead, we unmount that point if it is found, and we remount the
+              # entire shared host (not just an individual folder) with uid and gid applied. The
+              # container directory is only accessible via root, and the bind mounts result in the
+              # expected behavior.
+              current_mount_point = "#{VAGRANT_ROOT_MOUNT_POINT}/#{uid}-#{gid}"
+              hgfs_mount_options = "allow_other,default_permissions,uid=#{uid},gid=#{gid}"
+              hgfs_mount_options << ",#{options[:extra]}" if options[:extra]
+              hgfs_mount_options << ",#{options[:mount_options].join(',')}" if options[:mount_options]
+              hgfs_mount = "vmhgfs-fuse -o #{hgfs_mount_options} .host:/ '#{current_mount_point}'"
+
+              # Allow user to disable unmounting of default vmhgfs-fuse mount point at /mnt/hgfs
+              # by setting: `unmount_default_hgfs = false` in the provider config
+              if machine.provider_config.unmount_default_hgfs
+                machine.communicate.sudo <<-EOH.gsub(/^ */, '')
+                  if mount | grep /mnt/hgfs; then
+                    umount /mnt/hgfs
+                  fi
+                EOH
+              end
+
+              # Unique mount point based on uid/gid pair
+              machine.communicate.sudo <<-EOH.gsub(/^ */, '')
+                mount | grep " #{current_mount_point} "
+                if test $? -ne 0; then
+                  mkdir -p '#{current_mount_point}'
+                  chmod 700 '#{VAGRANT_ROOT_MOUNT_POINT}'
+                  #{hgfs_mount}
+                fi
+              EOH
+
+              # Finally bind mount to the expected guest location
+              mount_command = "mount --bind '#{current_mount_point}/#{name}' '#{expanded_guest_path}'"
+              machine.communicate.sudo(mount_command)
+            end
+
+            # Emit an upstart event if we can
+            machine.communicate.sudo <<-EOH.gsub(/^ {14}/, '')
+              if command -v /sbin/init && /sbin/init --version | grep upstart; then
+                /sbin/initctl emit --no-wait vagrant-mounted MOUNTPOINT='#{expanded_guest_path}'
+              fi
+            EOH
+          end
+        end
+      end
+    end
+  end
+end