vagrant-sshfs 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2d4ee117625b76ea4c7fb4a599a3cc4fa99f4a2c
-  data.tar.gz: 148d5131b8afa0b2b67280753a38da6ba3342bc7
+  metadata.gz: 74c0ac801cbf4908bc4c4afa128e205764b899fd
+  data.tar.gz: 0e842c7729c4bd1a746aa41c16506006720722a9
 SHA512:
-  metadata.gz: 5f47cf465600415b77f95da2453c2b79947c7b50758ea386d037bb80c6ec0cbacf75b556fae2494a684652dd6f2ea9ed0dae3d158b6b166609157805a27d6056
-  data.tar.gz: 31c56873df6f858699d0675a8da871e321426e61081c132da4d40efa9e29d56d798dc20e6c1283bf039ed89301d33299928d802ec0b4f92a0b9dea7d07800b86
+  metadata.gz: a2727626ab76dab2502ba3671e36999dbfd38efbba0528089d43f2f80169c862ed4555c70b8dd2acaa57873123511a1e60537ae8255f1edc331df0cf43d21615
+  data.tar.gz: abee837f9c6b2bd264204ae6990523213d3951c6dfe2a00e063a028ec4a7cd51e370c555a78805e8008a9983c4700efc003aac36f90f5daca02c6abe40333d98

data/.gitignore

@@ -0,0 +1,17 @@
+# Build artifacts
+pkg
+build
+
+# Ruby / Bundler
+Gemfile.lock
+.ruby-gemset
+.ruby-version
+
+# .vagrant dirs
+.vagrant
+
+# IDE config files
+.idea
+*.iml
+
+

data/Gemfile

@@ -6,9 +6,12 @@ group :development do
   # We depend on Vagrant for development, but we don't add it as a
   # gem dependency because we expect to be installed within the
   # Vagrant environment itself using `vagrant plugin`.
-  gem "vagrant", :git => "https://github.com/mitchellh/vagrant.git"
+  gem "vagrant", :git => "https://github.com/mitchellh/vagrant.git", :ref => 'v1.8.4'
 end
 
 group :plugins do
   gem "vagrant-sshfs" , path: "."
+  # Add vagrant-libvirt plugin here, otherwise you won't be able to
+  # use libvirt as a provider when you execute `bundle exec vagrant up`
+  gem "vagrant-libvirt" , '0.0.33'
 end

data/README.md

@@ -2,9 +2,9 @@
 
 This is a vagrant plugin that adds synced folder support for mounting
 folders from the Vagrant host into the Vagrant guest via
-[SSHFS](https://github.com/libfuse/sshfs). It does this by executing
-the `SSHFS` client software within the guest, which creates and SSH
-connection from the Vagrant guest back to the Vagrant host. 
+[SSHFS](https://github.com/libfuse/sshfs). In the default mode it does 
+this by executing the `SSHFS` client software within the guest, which 
+creates an SSH connection from the Vagrant guest back to the Vagrant host. 
 
 The benefits of this approach:
 - Works on any host platform and hypervisor type
@@ -35,7 +35,7 @@ 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
+### Sharing Vagrant Host Directory to Vagrant Guest - 98% of users
 
 This plugin uses SSHFS slave mounts 
 (see [link](https://github.com/dustymabe/vagrant-sshfs/issues/11))
@@ -58,6 +58,19 @@ See [Options](#options-specific-to-arbitrary-host-mounting) and
 [Appendix A](#appendix-a-using-keys-and-forwarding-ssh-agent) for
 more information.
 
+### Sharing Vagrant Guest Directory to Vagrant Host - 1% of users
+
+*NOTE:* This option is dangerous as data will be destroyed upon `vagrant destroy`
+
+This plugin allows you to share a folder from a Vagrant guest into the
+host. If you have workloads where there are a lot of disk intensive
+operations (such as compilation) it may be ideal to have the files
+live in the guest where the disk intensive operations would occur.
+For discussion see [Issue #7](https://github.com/dustymabe/vagrant-sshfs/issues/7).
+
+See [Options](#options-specific-to-reverse-mounting-guest-host-mount)
+for more information on how to enable this type of mount.
+
 ## Getting Started
 
 In order to use this synced folder implementation perform the
@@ -87,13 +100,13 @@ section.
 ## Executing the `vagrant sshfs` Command
 
 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.
+command from the command line. Executing this command with the `--mount`
+option will iterate through the Vagrant file and attempt to mount (via 
+SSHFS) any folders that aren't already mounted in the Vagrant guest.
+Executing with the `--unmount` option will unmount any mounted folders.
 
 ```
-vagrant sshfs
+vagrant sshfs [--mount|--unmount] [vm-name]
 ```
 
 ## Options
@@ -122,7 +135,7 @@ An example snippet from a `Vagrantfile`:
 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
+    disabled: false, type: "sshfs"
 ```
 
 ### Options Specific to Arbitrary Host Mounting
@@ -156,9 +169,49 @@ 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
+    disabled: false, type: "sshfs"
 ```
 
+### Options Specific to Reverse Mounting (Guest->Host Mount)
+
+If your host has the `sshfs` software installed then the following 
+options enable mounting a folder from a Vagrant Guest into the 
+Vagrant Host:
+
+- `reverse`
+    - This can be set to 'true' to enable reverse mounting a guest
+      folder into the Vagrant host.
+
+An example snippet from a `Vagrantfile` where we want to mount `/data`
+on the guest into `/guest/data` on the host:
+
+```
+config.vm.synced_folder "/guest/data", "/data", type: 'sshfs', reverse: true
+```
+
+## FAQ
+
+Here are some answers to some frequently asked questions:
+
+### Why do new files take time to appear inside the guest?
+
+Sometimes it can take time for files to appear on the other end of the
+sshfs mount. An example would be I create a file on my host system and
+then it doesn't show up inside the guest mount for 10 to 20 seconds.
+This is because of caching that SSHFS does to improve performance.
+Performance vs accuracy is always going to be a trade-off. If you'd
+like to disable caching completely you can disable caching completely
+by appending the `cache=no` SSHFS option to the synced folder
+definition in the Vagrantfile like so:
+
+```
+config.vm.synced_folder "/path/on/host", "/path/on/guest",
+    type: "sshfs", sshfs_opts_append: "-o cache=no"
+```
+
+All caching options that are available to sshfs can be added/modified
+in this same manner.
+
 ## Appendix A: Using Keys and Forwarding SSH Agent
 
 When [sharing an arbitrary host directory](#sharing-arbitrary-host-directory-to-vagrant-guest---1-of-users)
@@ -195,16 +248,24 @@ And finally bring up your Vagrant guest:
 
 ## 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:
+For local development of this plugin here is an example of how to build, test and install this plugin on your local machine:
 
 ```
-$ rake build
-vagrant-sshfs 0.1.0 built to pkg/vagrant-sshfs-0.1.0.gem.
-$ mkdir -p /tmp/gems/gems
-$ cp pkg/vagrant-sshfs-0.1.0.gem /tmp/gems/gems/                                                                                                          
-$ pushd /tmp/gems/
-$ gem generate_index
-$ popd
-$ vagrant plugin install vagrant-sshfs --plugin-source file:///tmp/gems/
+# Install development dependencies
+$ gem install bundler && bundle install
+
+# List available Rake tasks
+$ bundle exec rake -T
+
+# Run Cucumber tests
+$ bundle exec rake featuretests
+
+# Build the gem (gets generated in the 'pkg' directory
+$ bundle exec rake build
+
+# Run Vagrant in the context of the plugin
+$ bundle exec vagrant <command>
+
+# Install built gem into global Vagrant installation (run outside of git checkout!)
+$ vagrant plugin install <path to gem in pkg directory>
 ```

data/Rakefile

@@ -1,2 +1,38 @@
-require "bundler/gem_tasks"
+# A Rakefile is like a Makefile for ruby
+
+# bundler/gem_tasks provides functionality like:
+#   bundle exec rake build
+#   bundle exec rake install
+#   bundle exec rake release
+#
+require 'bundler/gem_tasks'
+
+# cucumber/rake/task provides us with an easy way to call cucumber
+require 'cucumber/rake/task'
+
+# rake/clean provides CLEAN/CLOBBER
+# http://www.virtuouscode.com/2014/04/28/rake-part-6-clean-and-clobber/
+# CLEAN - list to let rake know what files can be cleaned up after build
+# CLOBBER - list to let rake know what files are final products of the build
+#
+require 'rake/clean'
+
+
+# Add the build dir to the list of items to clean up
+CLEAN.include('build')
+
+# We want to keep the build artifacts in the pkg dir
+CLOBBER.include('pkg')
+
+# Define a Rake::Task that will do initialization for us
+# See http://www.ultrasaurus.com/2009/12/creating-a-custom-rake-task/
+task :init do
+  FileUtils.mkdir_p 'build'
+end
+
+# Create new Cucumber::Rake::Task that will run Cucumber tests
+Cucumber::Rake::Task.new(:featuretests)
+
+# Define Rake::Task dependency - run :init before :featuretests
+task :featuretests => :init
 

data/features/README.md

@@ -0,0 +1,21 @@
+
+We are using Cucumber for automated testing. Read more at the
+following two links:
+
+- [link1](https://en.wikipedia.org/wiki/Cucumber_(software))
+- [link2](http://www.methodsandtools.com/tools/cucumber.php)
+
+features/
+    This is the features directory. The features directory Contains
+    feature files, which all have a .feature extension. May contain
+    subdirectories to organize feature files.
+
+features/step_definitions
+    This directory contains step definition files, which are Ruby code 
+    and have a .rb extension.
+
+features/support
+    This directory contains supporting Ruby code. Files in support
+    load before those in step_definitions, which makes it useful for
+    such things as environment configuration (commonly done in a file
+    called env.rb).

data/features/sshfs_cwd_mount.feature

@@ -0,0 +1,46 @@
+# The language in this file is Gherkin. It is the language Cucumber
+# uses to define test cases and is designed to be non-technical and
+# human readable. All Gherkin files have a .feature extension
+#
+# See more here: https://en.wikipedia.org/wiki/Cucumber_(software)
+# 
+# Additoinally in the setup/env.rb file we set up Aruba. Aruba is used 
+# to define most of the basic step definitions that we use as part of 
+# the Gherkin syntax in this file.
+#
+# For more information on the step definitions provided see:
+# https://github.com/cucumber/aruba/tree/bb5d7ff71809b5461e29153ded793d2b9a3a0624/features/testing_frameworks/cucumber/steps
+#
+Feature: SSHFS mount of vagrant current working directory
+
+  Scenario Outline: SSHFS mounting of vagrant cwd
+    Given a file named "Vagrantfile" with:
+    """
+    Vagrant.configure('2') do |config|
+      config.vm.box = '<box>'
+      # Disable the default rsync
+      config.vm.synced_folder '.', '/vagrant', disabled: true
+
+      # If using libvirt and nested virt (vagrant in vagrant) then 
+      # we need to use a different network than 192.168.121.0
+      config.vm.provider :libvirt do |libvirt|
+        libvirt.management_network_name = 'vagrant-libvirt-test'
+        libvirt.management_network_address = '192.168.129.0/24'
+      end
+
+      # Mount up the current dir. It will have the Vagrantfile in there.
+      config.vm.synced_folder './', '/testdir', type: 'sshfs'
+    end
+    """
+    When I successfully run `bundle exec vagrant up`
+    Then stdout from "bundle exec vagrant up" should contain "Installing SSHFS client..."
+    And  stdout from "bundle exec vagrant up" should contain "Mounting SSHFS shared folder..."
+    And  stdout from "bundle exec vagrant up" should contain "Folder Successfully Mounted!"
+    # The code for the following test is in ./step_definitions/sshfs_cwd_mount_steps.rb
+    And vagrant current working directory should be mounted
+
+    Examples:
+      | box      |
+      | centos/7 |
+    
+    

data/features/step_definitions/sshfs_cwd_mount_steps.rb

@@ -0,0 +1,12 @@
+# This is a cucumber step definition. Cucumber scenarios become automated 
+# tests with the addition of what are called step definitions. A step 
+# definition is a block of code associated with one or more steps by a 
+# regular expression (or, in simple cases, a string).
+#
+# This is the step definition for the `And vagrant current working
+# directory should be mounted` step from sshfs_cwd_mount.feature
+#
+And(/^vagrant current working directory should be mounted$/) do
+  run("vagrant ssh -c 'ls /testdir/Vagrantfile'")
+  expect(last_command_started).to have_exit_status(0)
+end

data/features/support/env.rb

@@ -0,0 +1,27 @@
+# This is a support file for the cucumber tests. This file sets up the
+# environment for the tests to run. At this point mainly that means
+# configuring Aruba. Aruba is used to define most of the basic step
+# definitions that we use as part of the Gherkin syntax in our .feature files.
+#
+# For more information on the step definitions provided see:
+# https://github.com/cucumber/aruba/tree/bb5d7ff71809b5461e29153ded793d2b9a3a0624/features/testing_frameworks/cucumber/steps
+require 'aruba/cucumber'
+require 'komenda' # use komenda for easily executing a command
+
+# Configure aruba. The options can be inferred from here:
+# https://github.com/cucumber/aruba/tree/bb5d7ff71809b5461e29153ded793d2b9a3a0624/features/configuration
+Aruba.configure do |config|
+  # Wait up to 300 seconds for the test to run
+  config.exit_timeout = 300
+  # Output stdout and stderr on test failure
+  config.activate_announcer_on_command_failure = [:stdout, :stderr]
+  # The directory where the tests are to be run
+  config.working_directory = 'build/aruba'
+end
+
+# After running tests, clean up
+After do |_scenario|
+  if File.exist?(File.join(aruba.config.working_directory, 'Vagrantfile'))
+    Komenda.run('bundle exec vagrant destroy -f', cwd: aruba.config.working_directory, fail_on_fail: true)
+  end
+end

data/lib/vagrant-sshfs/cap/{linux/sshfs_mount.rb → guest/linux/sshfs_forward_mount.rb}

@@ -1,6 +1,13 @@
 require "log4r"
-
 require "vagrant/util/retryable"
+require "tempfile"
+
+# This is already done for us in lib/vagrant-sshfs.rb. We needed to
+# do it there before Process.uid is called the first time by Vagrant
+# This provides a new Process.create() that works on Windows.
+if Vagrant::Util::Platform.windows?
+  require 'win32/process'
+end
 
 module VagrantPlugins
   module GuestLinux
@@ -9,7 +16,7 @@ module VagrantPlugins
         extend Vagrant::Util::Retryable
         @@logger = Log4r::Logger.new("vagrant::synced_folders::sshfs_mount")
 
-        def self.sshfs_is_folder_mounted(machine, opts)
+        def self.sshfs_forward_is_folder_mounted(machine, opts)
           mounted = false
           # expand the guest path so we can handle things like "~/vagrant"
           expanded_guest_path = machine.guest.capability(
@@ -27,7 +34,7 @@ module VagrantPlugins
           return mounted
         end
 
-        def self.sshfs_mount_folder(machine, opts)
+        def self.sshfs_forward_mount_folder(machine, opts)
           # opts contains something like:
           #   { :type=>:sshfs,
           #     :guestpath=>"/sharedfolder",
@@ -69,8 +76,82 @@ module VagrantPlugins
           end
         end
 
+        def self.sshfs_forward_unmount_folder(machine, opts)
+          # opts contains something like:
+          #   { :type=>:sshfs,
+          #     :guestpath=>"/sharedfolder",
+          #     :hostpath=>"/guests/sharedfolder",
+          #     :disabled=>false
+          #     :ssh_host=>"192.168.1.1"
+          #     :ssh_port=>"22"
+          #     :ssh_username=>"username"
+          #     :ssh_password=>"password"
+          #   }
+
+          # expand the guest path so we can handle things like "~/vagrant"
+          expanded_guest_path = machine.guest.capability(
+            :shell_expand_guest_path, opts[:guestpath])
+
+          # Log some information
+          machine.ui.info(I18n.t("vagrant.sshfs.actions.unmounting_folder",
+                                 guestpath: expanded_guest_path))
+
+          # Build up the command and connect
+          error_class = VagrantPlugins::SyncedFolderSSHFS::Errors::SSHFSUnmountFailed
+          cmd = "umount #{expanded_guest_path}"
+          machine.communicate.sudo(
+            cmd, error_class: error_class, error_key: :unmount_failed)
+        end
+
         protected
 
+        def self.windows_uninherit_handles
+          # For win32-process Process.create, if we pass any file handles to the 
+          # underlying process for stdin/stdout/stderr then all file handles are 
+          # inherited by default. We'll explicitly go through and set all Handles
+          # to not be inheritable by default. See following links for more info
+          # 
+          # https://github.com/djberg96/win32-process/blob/6b380f450aebb69d44bb7accd958ecb6b9e1d246/lib/win32/process.rb#L445-L447
+          # bInheritHandles from https://msdn.microsoft.com/en-us/library/windows/desktop/ms682425(v=vs.85).aspx
+          # 
+          # For each open IO object 
+          ObjectSpace.each_object(IO) do |io|
+            if !io.closed?
+              fileno = io.fileno 
+              @@logger.debug("Setting file handle #{fileno} to not be inherited")
+              self.windows_uninherit_handle(fileno)
+            end
+          end
+        end
+
+        def self.windows_uninherit_handle(fileno)
+          # Right now we'll be doing this using private methods from the win32-process
+          # module by calling  For each open IO object. Much of this code was copied from 
+          # that module. We access the private methods by using the object.send(:method, args)
+          # technique. In the future we want to get a patch upstream so we don't need to
+          # access privat methods.
+
+          # Get the windows IO handle and make sure we were successful getting it
+          handle = Process.send(:get_osfhandle, fileno)
+          if handle == Process::Constants::INVALID_HANDLE_VALUE
+            ptr = FFI::MemoryPointer.new(:int)
+            if Process.send(:windows_version) >= 6 && Process.get_errno(ptr) == 0
+              errno = ptr.read_int
+            else
+              errno = FFI.errno
+            end
+            raise SystemCallError.new("get_osfhandle", errno)
+          end
+
+          # Now clear the HANDLE_FLAG_INHERIT from the HANDLE so that the handle
+          # won't get shared by default. See: 
+          # https://msdn.microsoft.com/en-us/library/windows/desktop/ms724935(v=vs.85).aspx
+          # 
+          bool = Process.send(:SetHandleInformation,
+          handle, Process::Constants::HANDLE_FLAG_INHERIT, 0)
+          raise SystemCallError.new("SetHandleInformation", FFI.errno) unless bool
+        end
+
         # 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)
@@ -115,6 +196,14 @@ module VagrantPlugins
           r1, w1 = IO.pipe # reader/writer from pipe1
           r2, w2 = IO.pipe # reader/writer from pipe2
 
+          # Log STDERR to predictable files so that we can inspect them
+          # later in case things go wrong. We'll use the machines data
+          # directory (i.e. .vagrant/machines/default/virtualbox/) for this
+          f1path = machine.data_dir.join('vagrant_sshfs_sftp_server_stderr.txt')
+          f2path = machine.data_dir.join('vagrant_sshfs_ssh_stderr.txt')
+          f1 = File.new(f1path, 'w+')
+          f2 = File.new(f2path, 'w+')
+
           # 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:
@@ -130,29 +219,50 @@ module VagrantPlugins
           #          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)
+          if Vagrant::Util::Platform.windows?
+            # For windows we need to set it so not all file handles are inherited
+            # by default. See https://github.com/dustymabe/vagrant-sshfs/issues/41
+            # The r1,r2,w1,w2,f1,f2 we pass below will get set back to be shared
+            self.windows_uninherit_handles
+            # For windows, we are using win32-process' Process.create because ruby
+            # doesn't properly detach processes. See https://github.com/dustymabe/vagrant-sshfs/issues/31
+            Process.create(:command_line => sftp_server_cmd,
+                           :creation_flags => Process::DETACHED_PROCESS,
+                           :process_inherit => false,
+                           :thread_inherit => true,
+                           :startup_info => {:stdin => w2, :stdout => r1, :stderr => f1})
+
+            Process.create(:command_line => ssh_cmd,
+                           :creation_flags => Process::DETACHED_PROCESS,
+                           :process_inherit => false,
+                           :thread_inherit => true,
+                           :startup_info => {:stdin => w1, :stdout => r2, :stderr => f2})
+          else
+            p1 = spawn(sftp_server_cmd, :out => w2, :in => r1, :err => f1, :pgroup => true)
+            p2 = spawn(ssh_cmd,         :out => w1, :in => r2, :err => f2, :pgroup => true)
+
+            # Detach from the processes so they will keep running
+            Process.detach(p1)
+            Process.detach(p2)
+          end
 
           # Check that the mount made it
           mounted = false
-          for i in 0..10
+          for i in 0..6
             machine.ui.info("Checking Mount..")
-            if self.sshfs_is_folder_mounted(machine, opts)
+            if self.sshfs_forward_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
+            f1.rewind # Seek to beginning of the file
+            f2.rewind # Seek to beginning of the file
+            error_class = VagrantPlugins::SyncedFolderSSHFS::Errors::SSHFSSlaveMountFailed
+            raise error_class, sftp_stderr: f1.read, ssh_stderr: f2.read
           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