vagrant-sshfs 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 349d3d3ae634f9bc990aa78814cf9c9b3fc694c7
-  data.tar.gz: 892801c2a7aca30bd99356feeb46220920f64718
+  metadata.gz: 2d4ee117625b76ea4c7fb4a599a3cc4fa99f4a2c
+  data.tar.gz: 148d5131b8afa0b2b67280753a38da6ba3342bc7
 SHA512:
-  metadata.gz: 4e8b60fbc21201acb835442e8f7eb4291b56df8663c761177555a384fcea8256c871916938aa1a181c82ed8d27d30ba529af80c6bc618eff019b8e3a88c0614b
-  data.tar.gz: fee9778ffc2af267f16c17f8ec9dfade6d7b8549eb7f08782a6e91a7c920c6e62d5c253164469a2912c71ba7413da80c3ca53a04ee35bc932e1d786f41ba827e
+  metadata.gz: 5f47cf465600415b77f95da2453c2b79947c7b50758ea386d037bb80c6ec0cbacf75b556fae2494a684652dd6f2ea9ed0dae3d158b6b166609157805a27d6056
+  data.tar.gz: 31c56873df6f858699d0675a8da871e321426e61081c132da4d40efa9e29d56d798dc20e6c1283bf039ed89301d33299928d802ec0b4f92a0b9dea7d07800b86

data/README.md

@@ -10,18 +10,17 @@ The benefits of this approach:
 - Works on any host platform and hypervisor type
     - Windows, Linux, Mac OS X
     - Virtualbox, Libvirt, Hyper-V, VMWare
+- Seamlessly works on remote Vagrant solutions
+    - Works with vagrant aws/openstack/etc.. plugins
 
 The drawbacks with this approach:
 - Performance is worse than an implementation like NFS
-- There must be an SSH daemon running on the Vagrant host 
-- The Vagrant guest must be able to SSH to the Vagrant host and authenticate.
+- There must be `sftp-server` software on the Vagrant host 
 
-Running an SSH daemon on the host is mainly only a problem on the
-Windows platform. [Here](http://docs.oracle.com/cd/E24628_01/install.121/e22624/preinstall_req_cygwin_ssh.htm#EMBSC150) 
-is a guide for intalling the cygwin SSH daemon on Windows.
-
-In order to authenticate back to the host daemon you must either
-provide your password or use SSH keys and agent forwarding.
+`sftp-server` is usually provided by SSH server software so it already
+exists on Linux/Mac. On windows you only need to install
+[openssh](https://cygwin.com/cgi-bin2/package-cat.cgi?file=x86_64%2Fopenssh%2Fopenssh-7.2p1-1&grep=openssh)
+via [cygwin](https://cygwin.com/) and you will get `sftp-server`.
 
 ## History
 
@@ -34,12 +33,37 @@ plugin just like the other synced folder plugins (NFS/RSYNC/SMB/VirtualBox).
 This plugin was developed mainly by copying the code from the NFS synced 
 folder plugin from the Vagrant core code and molding it to fit SSHFS.
 
+## Modes of Operation
+
+### Sharing Vagrant Host Directory to Vagrant Guest - 99% of users
+
+This plugin uses SSHFS slave mounts 
+(see [link](https://github.com/dustymabe/vagrant-sshfs/issues/11))
+to mount a directory from the Vagrant Host into the Vagrant Guest. It
+uses the `sftp-server` software that exists on the host and `sshfs`
+running in *slave mode* within the guest to create a connection using
+the existing authentication over SSH that vagrant sets up for you.
+
+### Sharing Arbitrary Host Directory to Vagrant Guest - 1% of users
+
+This plugin allows you to share a folder from an arbitrary host to the
+Vagrant Guest. This would allow you to do a folder mount to some other
+host that may have files that you need. To do this the plugin will run
+an SSHFS command from the Guest and connect to the arbitrary host that
+must have an SSH daemon running. You must provide the `ssh_host`
+option in the Vagrantfile to get this to work. You can use ssh key
+forwarding or username/password for authentication for this.
+
+See [Options](#options-specific-to-arbitrary-host-mounting) and 
+[Appendix A](#appendix-a-using-keys-and-forwarding-ssh-agent) for
+more information.
+
 ## Getting Started
 
 In order to use this synced folder implementation perform the
 following steps:
 
-### Install plugin
+### Install Plugin
 
 In order to install the plugin simply run the following command:
 
@@ -47,7 +71,7 @@ In order to install the plugin simply run the following command:
 # vagrant plugin install vagrant-sshfs
 ```
 
-### Add SSHFS synced folder in Vagrantfile
+### Add SSHFS Synced Folder in Vagrantfile
 
 Edit your Vagrantfile to specify a folder to mount from the host into
 the guest:
@@ -56,64 +80,66 @@ the guest:
 config.vm.synced_folder "/path/on/host", "/path/on/guest", type: "sshfs"
 ```
 
-For more options that you can add see the [Options](#options) section.
-
-### Recommended: Using Keys and Forwarding SSH Agent
-
+Now you can simply `vagrant up` and your folder should be mounted in
+the guest. For more options that you can add see the [Options](#options) 
+section.
 
-If you want a completely non-interactive experience you can either
-hard code your password in the Vagrantfile or you can use SSH keys.
+## Executing the `vagrant sshfs` Command
 
-If `key1` is a key that is authorized to log in to the Vagrant host
-,meaning there is an entry for `key1` in the `~/.ssh/authorized_keys` 
-file, then you should be able to do the following to have a
-non-interactive experience with SSH keys and agent forwarding:
-
-Modify the Vagrantfile to forward your SSH agent:
+The Vagrant SSHFS plugin also supports execution of the `vagrant sshfs`
+command from the command line. Executing this command will
+iterate through the Vagrant file and attempt to mount (via SSHFS) any
+folders that aren't already mounted in the Vagrant guest that is
+associated with the current directory.
 
 ```
-config.ssh.forward_agent = 'true'
+vagrant sshfs
 ```
 
-Now set up your agent and add your key to the agent:
+## Options
 
-```
-# eval $(ssh-agent)
-# ssh-add /path/to/key1
-```
+The SSHFS synced folder plugin supports a few options that can be
+provided in the `Vagrantfile`. The following sections describe the
+options in more detail.
 
-And finally bring up your Vagrant guest:
+### Generic Options
 
-```
-# vagrant up
-```
+The SSHFS synced folder plugin supports a few options that can be
+provided in the `Vagrantfile`. They are described below:
 
-## Executing the `vagrant sshfs` command
+- `disabled`
+    - If set to 'true', ignore this folder and don't mount it.
+- `ssh_opts_append`
+    - Add some options for the ssh connection that will be established.
+    - See the ssh man page for more details on possible options.
+- `sshfs_opts_append`
+    - Add some options for the sshfs fuse mount that will made
+    - See the sshfs man page for more details on possible options.
 
-The Vagrant SSHFS plugin also supports execution of the `vagrant sshfs`
-command from the command line. Executing this command will
-iterate through the Vagrant file and attempt to mount (via SSHFS) any
-folders that aren't already mounted in the Vagrant guest that is
-associated with the current directory.
+An example snippet from a `Vagrantfile`:
 
 ```
-vagrant sshfs
+config.vm.synced_folder "/path/on/host", "/path/on/guest",
+    ssh_opts_append: "-o Compression=yes -o CompressionLevel=5",
+    sshfs_opts_append: "-o auto_cache -o cache_timeout=115200",
+    disabled: false
 ```
 
-## Options
+### Options Specific to Arbitrary Host Mounting
 
-The SSHFS synced folder plugin supports a few options that can be
-provided on the command line. They are described below:
+The following options are only to be used when
+[sharing an arbitrary host directory](#sharing-arbitrary-host-directory-to-vagrant-guest---1-of-users)
+with the guest. They will be ignored otherwise:
 
 - `ssh_host`
     - The host to connect to via SSH. If not provided this will be 
       detected as the Vagrant host that is running the Vagrant guest.
 - `ssh_port`
     - The port to use when connecting. Defaults to port 22.
-- `ssh_username` 
+- `ssh_username`
     - The username to use when connecting. If not provided it is
     detected as the current user who is interacting with Vagrant.
-- `ssh_password` - NOT RECOMMENDED
+- `ssh_password`
     - The password to use when connecting. If not provided and the
       user is not using SSH keys, then the user will be prompted for
       the password. Please use SSH keys and don't use this option!
@@ -122,19 +148,52 @@ provided on the command line. They are described below:
       a password by setting this to 'true'. Alternatively the user can
       deny Vagrant from ever prompting for the password by setting
       this to 'false'.
-- `disabled`
-    - If set to 'true', ignore this folder and don't mount it.
 
-Here is an example of how to use the options:
+An example snippet from a `Vagrantfile`:
 
 ```
-config.vm.synced_folder "/path/on/host", "/path/on/guest", 
-    type: "sshfs",
-    ssh_username: "user1",
-    ssh_port: "22"
+config.vm.synced_folder "/path/on/host", "/path/on/guest",
+    ssh_host: "somehost.com", ssh_username: "fedora",
+    ssh_opts_append: "-o Compression=yes -o CompressionLevel=5",
+    sshfs_opts_append: "-o auto_cache -o cache_timeout=115200",
+    disabled: false
 ```
 
-## Development
+## Appendix A: Using Keys and Forwarding SSH Agent
+
+When [sharing an arbitrary host directory](#sharing-arbitrary-host-directory-to-vagrant-guest---1-of-users)
+you may want a completely non-interactive experience. You can either
+hard code your password in the Vagrantfile or you can use SSH keys.
+A few guides for setting up ssh keys and key forwarding are on Github:
+- [Key Generation](https://help.github.com/articles/generating-ssh-keys)
+- [Key Forwarding](https://developer.github.com/guides/using-ssh-agent-forwarding/)
+
+The idea is that if `key1` is a key that is authorized to log in to the 
+Vagrant host ,meaning there is an entry for `key1` in the `~/.ssh/authorized_keys` 
+file, then you should be able to do the following to have a
+non-interactive experience with SSH keys and agent forwarding:
+
+Modify the Vagrantfile to forward your SSH agent:
+
+```
+config.ssh.forward_agent = 'true'
+```
+
+Now set up your agent and add your key to the agent:
+
+```
+# eval $(ssh-agent)
+# ssh-add /path/to/key1
+```
+
+And finally bring up your Vagrant guest:
+
+```
+# vagrant up
+```
+
+
+## Appendix B: Development
 
 For local development of this plugin here is an example of how to build 
 and install this plugin on your local machine:

data/lib/vagrant-sshfs/cap/linux/sshfs_mount.rb

@@ -1,3 +1,5 @@
+require "log4r"
+
 require "vagrant/util/retryable"
 
 module VagrantPlugins
@@ -5,6 +7,25 @@ module VagrantPlugins
     module Cap
       class MountSSHFS
         extend Vagrant::Util::Retryable
+        @@logger = Log4r::Logger.new("vagrant::synced_folders::sshfs_mount")
+
+        def self.sshfs_is_folder_mounted(machine, opts)
+          mounted = false
+          # expand the guest path so we can handle things like "~/vagrant"
+          expanded_guest_path = machine.guest.capability(
+            :shell_expand_guest_path, opts[:guestpath])
+          machine.communicate.execute("cat /proc/mounts") do |type, data|
+            if type == :stdout
+              data.each_line do |line|
+                if line.split()[1] == expanded_guest_path
+                  mounted = true
+                  break
+                end
+              end
+            end
+          end
+          return mounted
+        end
 
         def self.sshfs_mount_folder(machine, opts)
           # opts contains something like:
@@ -22,67 +43,160 @@ module VagrantPlugins
           expanded_guest_path = machine.guest.capability(
             :shell_expand_guest_path, opts[:guestpath])
 
-          # Do the actual creating and mounting
-          machine.communicate.sudo("mkdir -p #{expanded_guest_path}")
+          # Create the mountpoint inside the guest
+          machine.communicate.tap do |comm|
+            comm.sudo("mkdir -p #{expanded_guest_path}")
+            comm.sudo("chmod 777 #{expanded_guest_path}")
+          end
 
           # Mount path information
           hostpath = opts[:hostpath].dup
           hostpath.gsub!("'", "'\\\\''")
 
+          # Add in some sshfs/fuse options that are common to both mount methods
+          opts[:sshfs_opts] = ' -o allow_other ' # allow non-root users to access
+          opts[:sshfs_opts]+= ' -o noauto_cache '# disable caching based on mtime
+
+          # Add in some ssh options that are common to both mount methods
+          opts[:ssh_opts] = ' -o StrictHostKeyChecking=no '# prevent yes/no question 
+          opts[:ssh_opts]+= ' -o ServerAliveInterval=30 '  # send keepalives
+
+          # Do a normal mount only if the user provided host information
+          if opts.has_key?(:ssh_host) and opts[:ssh_host]
+            self.sshfs_normal_mount(machine, opts, hostpath, expanded_guest_path)
+          else
+            self.sshfs_slave_mount(machine, opts, hostpath, expanded_guest_path)
+          end
+        end
+
+        protected
+
+        # Perform a mount by running an sftp-server on the vagrant host 
+        # and piping stdin/stdout to sshfs running inside the guest
+        def self.sshfs_slave_mount(machine, opts, hostpath, expanded_guest_path)
+
+          sftp_server_path = opts[:sftp_server_exe_path]
+          ssh_path = opts[:ssh_exe_path]
+
+          # SSH connection options
+          ssh_opts = opts[:ssh_opts]
+          ssh_opts_append = opts[:ssh_opts_append].to_s # provided by user
+
+          # SSHFS executable options
+          sshfs_opts = opts[:sshfs_opts]
+          sshfs_opts_append = opts[:sshfs_opts_append].to_s # provided by user
+
+          # The sftp-server command
+          sftp_server_cmd = sftp_server_path
+
+          # The remote sshfs command that will run (in slave mode)
+          sshfs_opts+= ' -o slave '
+          sshfs_cmd = "sudo -E sshfs :#{hostpath} #{expanded_guest_path}" 
+          sshfs_cmd+= sshfs_opts + ' ' + sshfs_opts_append + ' '
+
+          # The ssh command to connect to guest and then launch sshfs
+          ssh_opts = opts[:ssh_opts]
+          ssh_opts+= ' -o User=' + machine.ssh_info[:username]
+          ssh_opts+= ' -o Port=' + machine.ssh_info[:port].to_s
+          ssh_opts+= ' -o IdentityFile=' + machine.ssh_info[:private_key_path][0]
+          ssh_opts+= ' -o UserKnownHostsFile=/dev/null '
+          ssh_opts+= ' -F /dev/null ' # Don't pick up options from user's config
+          ssh_cmd = ssh_path + ssh_opts + ' ' + ssh_opts_append + ' ' + machine.ssh_info[:host]
+          ssh_cmd+= ' "' + sshfs_cmd + '"'
+
           # Log some information
-          machine.ui.info(I18n.t("vagrant.sshfs.actions.mounting_folder", 
+          @@logger.debug("sftp-server cmd: #{sftp_server_cmd}")
+          @@logger.debug("ssh cmd: #{ssh_cmd}")
+          machine.ui.info(I18n.t("vagrant.sshfs.actions.slave_mounting_folder", 
                           hostpath: hostpath, guestpath: expanded_guest_path))
 
-          # Figure out any options
-          # TODO - Allow options override via an option
-          mount_opts = '-o StrictHostKeyChecking=no '
-          mount_opts+= '-o allow_other '
-          mount_opts+= '-o noauto_cache '
+          # Create two named pipes for communication between sftp-server and
+          # sshfs running in slave mode
+          r1, w1 = IO.pipe # reader/writer from pipe1
+          r2, w2 = IO.pipe # reader/writer from pipe2
+
+          # The way this works is by hooking up the stdin+stdout of the
+          # sftp-server process to the stdin+stdout of the sshfs process
+          # running inside the guest in slave mode. An illustration is below:
+          # 
+          #          stdout => w1      pipe1         r1 => stdin 
+          #         />------------->==============>----------->\
+          #        /                                            \
+          #        |                                            |
+          #    sftp-server (on vm host)                      sshfs (inside guest)
+          #        |                                            |
+          #        \                                            /
+          #         \<-------------<==============<-----------</
+          #          stdin <= r2        pipe2         w2 <= stdout 
+          #
+          # Wire up things appropriately and start up the processes
+          p1 = spawn(sftp_server_cmd,  :out => w2, :in => r1)
+          p2 = spawn(ssh_cmd, :out => w1, :in => r2)
+
+          # Check that the mount made it
+          mounted = false
+          for i in 0..10
+            machine.ui.info("Checking Mount..")
+            if self.sshfs_is_folder_mounted(machine, opts)
+              mounted = true
+              break
+            end
+            sleep(2)
+          end
+          if !mounted
+            Process.kill("TERM", p1) 
+            Process.kill("TERM", p2) 
+            raise VagrantPlugins::SyncedFolderSSHFS::Errors::SSHFSSlaveMountFailed
+          end
+          machine.ui.info("Folder Successfully Mounted!")
+
+          # Detach from the processes so they will keep running
+          Process.detach(p1)
+          Process.detach(p2)
+        end
+
+        # Do a normal sshfs mount in which we will ssh into the guest
+        # and then execute the sshfs command to connect the the opts[:ssh_host]
+        # and mount a folder from opts[:ssh_host] into the guest.
+        def self.sshfs_normal_mount(machine, opts, hostpath, expanded_guest_path)
 
-          # TODO some other options we might use in the future to help
-          # connections over low bandwidth
-          #options+= '-o kernel_cache -o Ciphers=arcfour -o big_writes -o auto_cache -o cache_timeout=115200 -o attr_timeout=115200 -o entry_timeout=1200 -o max_readahead=90000 '
-          #options+= '-o kernel_cache -o big_writes -o auto_cache -o cache_timeout=115200 -o attr_timeout=115200 -o entry_timeout=1200 -o max_readahead=90000 '
-          #options+= '-o cache_timeout=3600 '
+          # SSH connection options
+          ssh_opts = opts[:ssh_opts]
+          ssh_opts_append = opts[:ssh_opts_append].to_s # provided by user
 
+          # SSHFS executable options
+          sshfs_opts = opts[:sshfs_opts]
+          sshfs_opts_append = opts[:sshfs_opts_append].to_s # provided by user
+
+          # Host/Port and Auth Information
           username = opts[:ssh_username]
           password = opts[:ssh_password]
           host     = opts[:ssh_host]
           port     = opts[:ssh_port]
 
+          # Add echo of password if password is being used
           echopipe = ""
           if password
             echopipe = "echo '#{password}' | "
-            mount_opts+= '-o password_stdin '
+            sshfs_opts+= '-o password_stdin '
           end
+
+          # Log some information
+          machine.ui.info(I18n.t("vagrant.sshfs.actions.normal_mounting_folder", 
+                          user: username, host: host, 
+                          hostpath: hostpath, guestpath: expanded_guest_path))
           
-          error_class = VagrantPlugins::SyncedFolderSSHFS::Errors::SSHFSMountFailed
+          # Build up the command and connect
+          error_class = VagrantPlugins::SyncedFolderSSHFS::Errors::SSHFSNormalMountFailed
           cmd = echopipe 
           cmd+= "sshfs -p #{port} "
-          cmd+= mount_opts
+          cmd+= ssh_opts + ' ' + ssh_opts_append + ' '
+          cmd+= sshfs_opts + ' ' + sshfs_opts_append + ' '
           cmd+= "#{username}@#{host}:'#{hostpath}' #{expanded_guest_path}"
           retryable(on: error_class, tries: 3, sleep: 3) do
             machine.communicate.sudo(
-              cmd, error_class: error_class, error_key: :mount_failed)
-          end
-        end
-
-        def self.sshfs_is_folder_mounted(machine, opts)
-          mounted = false
-          # expand the guest path so we can handle things like "~/vagrant"
-          expanded_guest_path = machine.guest.capability(
-            :shell_expand_guest_path, opts[:guestpath])
-          machine.communicate.execute("cat /proc/mounts") do |type, data|
-            if type == :stdout
-              data.each_line do |line|
-                if line.split()[1] == expanded_guest_path
-                  mounted = true
-                  break
-                end
-              end
-            end
+              cmd, error_class: error_class, error_key: :normal_mount_failed)
           end
-          return mounted
         end
       end
     end

data/lib/vagrant-sshfs/errors.rb

@@ -6,8 +6,12 @@ module VagrantPlugins
         error_namespace("vagrant.sshfs.errors")
       end
 
-      class SSHFSMountFailed < SSHFSError
-        error_key(:mount_failed)
+      class SSHFSNormalMountFailed < SSHFSError
+        error_key(:normal_mount_failed)
+      end
+
+      class SSHFSSlaveMountFailed < SSHFSError
+        error_key(:slave_mount_failed)
       end
 
       class SSHFSInstallFailed < SSHFSError
@@ -17,6 +21,10 @@ module VagrantPlugins
       class SSHFSNotInstalledInGuest < SSHFSError
         error_key(:sshfs_not_in_guest)
       end
+
+      class SSHFSExeNotAvailable < SSHFSError
+        error_key(:exe_not_in_host)
+      end
     end
   end
 end

data/lib/vagrant-sshfs/synced_folder.rb

@@ -1,13 +1,16 @@
+require "log4r"
+
 require "vagrant/util/platform"
+require "vagrant/util/which"
 
 module VagrantPlugins
   module SyncedFolderSSHFS
     class SyncedFolder < Vagrant.plugin("2", :synced_folder)
-      @@vagrant_host_machine_ip
 
       def initialize(*args)
         super
-        @@vagrant_host_machine_ip = nil
+
+        @logger = Log4r::Logger.new("vagrant::synced_folders::sshfs")
       end
 
       # This is called early when the synced folder is set to determine
@@ -30,8 +33,10 @@ module VagrantPlugins
       # any existing ones.
       #
       # No return value.
-      def enable(machine, folders, sshfsopts)
-       if machine.guest.capability?(:sshfs_installed)
+      def enable(machine, folders, pluginopts)
+
+        # Check to see if sshfs software is in the guest
+        if machine.guest.capability?(:sshfs_installed)
           if !machine.guest.capability(:sshfs_installed)
             can_install = machine.guest.capability?(:sshfs_install)
             if !can_install
@@ -42,6 +47,7 @@ module VagrantPlugins
           end
         end
 
+        # Iterate through the folders and mount if needed
         folders.each do |id, opts|
 
           # If already mounted then there is nothing to do
@@ -52,10 +58,21 @@ module VagrantPlugins
             next
           end
 
-          # Find out the host info and auth info for each folder
-          get_host_info(machine, opts)
-          get_auth_info(machine, opts)
-
+          # If the synced folder entry has host information in it then
+          # assume we are doing a normal sshfs mount to a host that isn't
+          # the machine running vagrant. Rely on password/ssh keys.
+          #
+          # If not, then we are doing a slave mount and we need to
+          # make sure we can find the sftp-server and ssh execuatable
+          # files on the host.
+          if opts.has_key?(:ssh_host) and opts[:ssh_host]
+              # Check port information and find out auth info
+              check_host_port(machine, opts)
+              get_auth_info(machine, opts)
+          else
+              opts[:ssh_exe_path] = find_executable('ssh')
+              opts[:sftp_server_exe_path] = find_executable('sftp-server')
+          end
           # Do the mount
           machine.ui.info(I18n.t("vagrant.sshfs.actions.mounting"))
           machine.guest.capability(:sshfs_mount_folder, opts)
@@ -75,47 +92,17 @@ module VagrantPlugins
 
       protected
 
-      def get_host_info(machine, opts)
-        # opts - the synced folder options hash
-        # machine - 
-
-        # If the synced folder entry doesn't have host information in it then
-        # detect the vagrant host machine IP and use that
-        if not opts.has_key?(:ssh_host) or not opts[:ssh_host]
-            opts[:ssh_host] = detect_vagrant_host_ip(machine)
-        end
-
-        # If the synced folder doesn't have host port information in it 
-        # default to port 22 for ssh
-        # detect the vagrant host machine IP and use that
+      # Check if port information was provided in the options. If not,
+      # then default to port 22 for ssh
+      def check_host_port(machine, opts)
         if not opts.has_key?(:ssh_port) or not opts[:ssh_port]
             opts[:ssh_port] = '22'
         end
       end
 
-      def detect_vagrant_host_ip(machine)
-        # Only run detection if it hasn't been run before
-        if not @@vagrant_host_machine_ip
-          # Attempt to detect host machine IP by connecting over ssh
-          # and then using the $SSH_CONNECTION env variable information to
-          # determine the vagrant host IP address
-          hostip = ''
-          machine.communicate.execute('echo $SSH_CONNECTION') do |type, data|
-            if type == :stdout
-              hostip = data.split()[0]
-            end
-          end
-          # TODO do some error checking here to make sure hostip was detected
-          machine.ui.info(I18n.t("vagrant.sshfs.info.detected_host_ip", ip: hostip))
-          @@vagrant_host_machine_ip = hostip
-        end
-        # Return the detected host IP
-        @@vagrant_host_machine_ip
-      end
-
+      # Function to gather authentication information (username/password)
+      # for doing a normal sshfs mount
       def get_auth_info(machine, opts)
-        # opts - the synced folder options hash
-        # machine - 
         prompt_for_password = false
         ssh_info = machine.ssh_info
 
@@ -149,6 +136,34 @@ module VagrantPlugins
               echo: false)
         end
       end
+
+      # Function to find the path to an executable with name "name"
+      def find_executable(name)
+        error_class = VagrantPlugins::SyncedFolderSSHFS::Errors::SSHFSExeNotAvailable
+
+        # Save off PATH env var before we modify it
+        oldpath = ENV['PATH']
+
+        # Try to include paths where sftp-server may live so
+        # That we have a good chance of finding it
+        if Vagrant::Util::Platform.windows? and
+             Vagrant::Util::Platform.cygwin?
+          cygwin_root = Vagrant::Util::Platform.cygwin_windows_path('/')
+          ENV['PATH'] += ';' + cygwin_root + '\usr\sbin'
+        else
+          ENV['PATH'] += ':/usr/libexec/openssh' # Linux (Red Hat Family)
+          ENV['PATH'] += ':/usr/lib/openssh'     # Linux (Debian Family)
+          ENV['PATH'] += ':/usr/libexec/'        # Mac OS X
+        end
+
+        # Try to find the executable
+        exepath = Vagrant::Util::Which.which(name)
+        raise error_class, executable: name if !exepath
+
+        # Restore the PATH variable and return
+        ENV['PATH'] = oldpath
+        return exepath
+      end
     end
   end
 end

data/lib/vagrant-sshfs/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module SyncedFolderSSHFS
-    VERSION = "1.0.0"
+    VERSION = "1.1.0"
   end
 end

data/locales/synced_folder_sshfs.yml

@@ -4,8 +4,10 @@ en:
       actions:
         installing: Installing SSHFS client...
         mounting: Mounting SSHFS shared folders...
-        mounting_folder: |-
+        slave_mounting_folder: |-
           Mounting folder via SSHFS: %{hostpath} => %{guestpath}
+        normal_mounting_folder: |-
+          Mounting folder via SSHFS: %{user}@%{host}:%{hostpath} => %{guestpath}
       ask:
         prompt_for_password: |-
           SSHFS password for '%{username}':
@@ -18,6 +20,10 @@ en:
         communicator_not_ready: |-
           The machine is reporting that it is not ready to communicate via ssh. Verify
           this machine is properly running.
+        exe_not_in_host: |-
+          The '%{executable}' executable file can't be found on the host machine but
+          is required for sshfs mounting to work. Please install the software and 
+          try again.
         sshfs_not_in_guest: |-
           The necessary SSHFS software is not installed in the guest. 
         install_failed_arch: |-
@@ -27,10 +33,10 @@ en:
 
           [1] https://wiki.archlinux.org/index.php/pacman#Packages_cannot_be_retrieved_on_installation
           [2] https://wiki.archlinux.org/index.php/System_maintenance#Partial_upgrades_are_unsupported
-        mount_failed: |-
-          Mounting SSHFS shared folders failed. This is most often caused by either
-          an SSH Daemon not running on the host or invalid credentials being provided.
-          Please make sure an SSH daemon is running on the host and proper credentials 
+        normal_mount_failed: |-
+          Mounting SSHFS shared folders failed. This is most often caused by either an
+          SSH Daemon not running on the target host or invalid credentials being provided.
+          Please make sure an SSH daemon is running on the host and proper credentials
           were provided to be able to authenticate via SSH.
 
           The command and output are:
@@ -44,3 +50,7 @@ en:
           Stderr from the command:
 
           %{stderr}
+        slave_mount_failed: |-
+          Mounting SSHFS shared via slave SSHFS mount failed. Please look at your 
+          terminal scrollback to look for any error messages from the processes that 
+          were run.

data/vagrant-sshfs.gemspec

@@ -13,8 +13,8 @@ Gem::Specification.new do |spec|
     This is the successor to Fabio Kreusch's implementation:
     https://github.com/fabiokr/vagrant-sshfs"""
   spec.summary       = spec.description
-  spec.homepage      = ""
-  spec.license       = "GPL"
+  spec.homepage      = "https://github.com/dustymabe/vagrant-sshfs"
+  spec.license       = "GPL-2.0"
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-sshfs
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Dusty Mabe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-14 00:00:00.000000000 Z
+date: 2016-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,9 +65,9 @@ files:
 - lib/vagrant-sshfs/version.rb
 - locales/synced_folder_sshfs.yml
 - vagrant-sshfs.gemspec
-homepage: ''
+homepage: https://github.com/dustymabe/vagrant-sshfs
 licenses:
-- GPL
+- GPL-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []