vagrant-sshfs 0.0.8 → 1.0.0

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/vagrant-sshfs.rb

@@ -4,20 +4,18 @@ rescue LoadError
   raise "The Vagrant sshfs plugin must be run within Vagrant"
 end
 
-require "vagrant-sshfs/version"
 require "vagrant-sshfs/errors"
+require "vagrant-sshfs/version"
 require "vagrant-sshfs/plugin"
-require "vagrant-sshfs/actions"
-require "vagrant-sshfs/command"
 
-module Vagrant
-  module SshFS
+module VagrantPlugins
+  module SyncedFolderSSHFS
     # Returns the path to the source of this plugin
     def self.source_root
       @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
     end
 
-    I18n.load_path << File.expand_path('locales/en.yml', source_root)
+    I18n.load_path << File.expand_path('locales/synced_folder_sshfs.yml', source_root)
     I18n.reload!
   end
 end

data/lib/vagrant-sshfs/cap/arch/sshfs_client.rb

@@ -0,0 +1,29 @@
+module VagrantPlugins
+  module GuestArch
+    module Cap
+      class SSHFSClient
+        def self.sshfs_install(machine)
+          # Attempt to install sshfs but note that it may likely fail
+          # because the package file list is out of date (see [1]). A
+          # logical answer to this problem would be to update the
+          # package list and then install the package, but since arch
+          # doesn't support partial upgrades [2] that would require
+          # updating all packages in the system first. Not ideal
+          #
+          # [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
+
+          error_class = VagrantPlugins::SyncedFolderSSHFS::Errors::SSHFSInstallFailed
+          error_key = :install_failed_arch
+          cmd = "pacman --noconfirm -S sshfs"
+          machine.communicate.sudo(
+            cmd, error_class: error_class, error_key: error_key)
+        end
+
+        def self.sshfs_installed(machine)
+          machine.communicate.test("pacman -Q sshfs")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-sshfs/cap/debian/sshfs_client.rb

@@ -0,0 +1,15 @@
+module VagrantPlugins
+  module GuestDebian
+    module Cap
+      class SSHFSClient
+        def self.sshfs_install(machine)
+          machine.communicate.sudo("apt-get install -y sshfs")
+        end
+
+        def self.sshfs_installed(machine)
+          machine.communicate.test("dpkg -l sshfs")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-sshfs/cap/fedora/sshfs_client.rb

@@ -0,0 +1,15 @@
+module VagrantPlugins
+  module GuestFedora
+    module Cap
+      class SSHFSClient
+        def self.sshfs_install(machine)
+          machine.communicate.sudo("dnf -y install fuse-sshfs")
+        end
+
+        def self.sshfs_installed(machine)
+          machine.communicate.test("rpm -q fuse-sshfs")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module VagrantPlugins
+  module GuestLinux
+    module Cap
+      class SSHFSClient
+        def self.sshfs_installed(machine)
+          machine.communicate.test("test -x /usr/bin/sshfs")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+require "vagrant/util/retryable"
+
+module VagrantPlugins
+  module GuestLinux
+    module Cap
+      class MountSSHFS
+        extend Vagrant::Util::Retryable
+
+        def self.sshfs_mount_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])
+
+          # Do the actual creating and mounting
+          machine.communicate.sudo("mkdir -p #{expanded_guest_path}")
+
+          # Mount path information
+          hostpath = opts[:hostpath].dup
+          hostpath.gsub!("'", "'\\\\''")
+
+          # Log some information
+          machine.ui.info(I18n.t("vagrant.sshfs.actions.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 '
+
+          # 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 '
+
+          username = opts[:ssh_username]
+          password = opts[:ssh_password]
+          host     = opts[:ssh_host]
+          port     = opts[:ssh_port]
+
+          echopipe = ""
+          if password
+            echopipe = "echo '#{password}' | "
+            mount_opts+= '-o password_stdin '
+          end
+          
+          error_class = VagrantPlugins::SyncedFolderSSHFS::Errors::SSHFSMountFailed
+          cmd = echopipe 
+          cmd+= "sshfs -p #{port} "
+          cmd+= mount_opts
+          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
+          end
+          return mounted
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-sshfs/cap/redhat/sshfs_client.rb

@@ -0,0 +1,36 @@
+module VagrantPlugins
+  module GuestRedHat
+    module Cap
+      class SSHFSClient
+        def self.sshfs_install(machine)
+          # Install epel rpm if not installed 
+          if !epel_installed(machine)
+            epel_install(machine)
+          end
+
+          # Install sshfs (comes from epel repos)
+          machine.communicate.sudo("yum -y install fuse-sshfs")
+        end
+
+        def self.sshfs_installed(machine)
+          machine.communicate.test("rpm -q fuse-sshfs")
+        end
+        
+        protected
+
+        def self.epel_installed(machine)
+          machine.communicate.test("rpm -q epel-release")
+        end
+
+        def self.epel_install(machine)
+          case machine.guest.capability("flavor")
+            when :rhel_7
+              machine.communicate.sudo("rpm -ivh https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm")
+            when :rhel # rhel6 
+              machine.communicate.sudo("rpm -ivh https://dl.fedoraproject.org/pub/epel/epel-release-latest-6.noarch.rpm")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-sshfs/cap/suse/sshfs_client.rb

@@ -0,0 +1,15 @@
+module VagrantPlugins
+  module GuestSUSE
+    module Cap
+      class SSHFSClient
+        def self.sshfs_install(machine)
+          machine.communicate.sudo("zypper -n install sshfs")
+        end
+
+        def self.sshfs_installed(machine)
+          machine.communicate.test("rpm -q sshfs")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-sshfs/command.rb

@@ -1,25 +1,45 @@
-module Vagrant
-  module SshFS
-    class Command < Vagrant.plugin(2, :command)
-      def self.synopsis
-        "mounts sshfs shared folders"
-      end
+module VagrantPlugins
+  module SyncedFolderSSHFS
+    module Command
+      class SSHFS < Vagrant.plugin("2", :command)
+
+        include Vagrant::Action::Builtin::MixinSyncedFolders
 
-      def execute
-        with_target_vms do |machine|
-          get_builder(machine).mount!
+        def self.synopsis
+          "mounts SSHFS shared folder mounts into the remote machine"
         end
 
-        0
-      end
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant sshfs"
+            o.separator ""
+            o.separator "Mount all sshfs synced folders into the vagrant box"
+            o.separator ""
+          end
+
+          # Parse the options and return if we don't have any target.
+          argv = parse_options(opts)
+          return if !argv
+
+          # Go through each machine and perform the rsync
+          error = false
+          with_target_vms(argv) do |machine|
+
+            # Is the machine up yet?
+            if !machine.communicate.ready?
+              machine.ui.error(I18n.t("vagrant.sshfs.errors.communicator_not_ready"))
+              error = true
+              next
+            end
 
-      private
+            # Determine the sshfs synced folders for this machine
+            folders = synced_folders(machine, cached: false)[:sshfs]
+            next if !folders || folders.empty?
 
-      def get_builder(machine)
-        if machine.config.sshfs.mount_on_guest
-          Builders::Guest.new(machine, @env.ui)
-        else
-          Builders::Host.new(machine, @env.ui)
+            # Sync them!
+            SyncedFolder.new.enable(machine, folders, {})
+          end
+          return error ? 1 : 0
         end
       end
     end

data/lib/vagrant-sshfs/errors.rb

@@ -1,7 +1,22 @@
-module Vagrant
-  module SshFS
-    class Error < Errors::VagrantError
-      error_namespace("vagrant.config.sshfs.error")
+module VagrantPlugins
+  module SyncedFolderSSHFS
+    module Errors
+      # A convenient superclass for all our errors.
+      class SSHFSError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant.sshfs.errors")
+      end
+
+      class SSHFSMountFailed < SSHFSError
+        error_key(:mount_failed)
+      end
+
+      class SSHFSInstallFailed < SSHFSError
+        error_key(:install_failed)
+      end
+
+      class SSHFSNotInstalledInGuest < SSHFSError
+        error_key(:sshfs_not_in_guest)
+      end
     end
   end
 end

data/lib/vagrant-sshfs/plugin.rb

@@ -1,45 +1,85 @@
-module Vagrant
-  module SshFS
+require "vagrant"
+
+module VagrantPlugins
+  module SyncedFolderSSHFS
+    # This plugin implements SSHFS synced folders.
     class Plugin < Vagrant.plugin("2")
-      name "vagrant-sshfs"
-      description "A Vagrant plugin that mounts sshfs in the host machine."
+      name "SSHFS synced folders"
+      description <<-EOF
+      The SSHFS synced folders plugin enables you to use SSHFS as a synced folder
+      implementation.
+      EOF
+
+      synced_folder("sshfs", 5) do
+        require_relative "synced_folder"
+        SyncedFolder
+      end
+
+      command("sshfs", primary: false) do
+        require_relative "command"
+        Command::SSHFS
+      end
+
+      guest_capability("linux", "sshfs_mount_folder") do
+        require_relative "cap/linux/sshfs_mount"
+        VagrantPlugins::GuestLinux::Cap::MountSSHFS
+      end
+
+      guest_capability("linux", "sshfs_is_folder_mounted") do
+        require_relative "cap/linux/sshfs_mount"
+        VagrantPlugins::GuestLinux::Cap::MountSSHFS
+      end
 
-      config "sshfs" do
-        require "vagrant-sshfs/config"
-        Config
+      guest_capability("redhat", "sshfs_installed") do
+        require_relative "cap/redhat/sshfs_client"
+        VagrantPlugins::GuestRedHat::Cap::SSHFSClient
       end
 
-      action_hook(:sshfs, :machine_action_up) do |hook|
-        hook.append(Vagrant::SshFS::Actions::Up)
+      guest_capability("redhat", "sshfs_install") do
+        require_relative "cap/redhat/sshfs_client"
+        VagrantPlugins::GuestRedHat::Cap::SSHFSClient
       end
 
-      action_hook(:sshfs, :machine_action_reload) do |hook|
-        hook.append(Vagrant::SshFS::Actions::Reload)
+      guest_capability("fedora", "sshfs_installed") do
+        require_relative "cap/fedora/sshfs_client"
+        VagrantPlugins::GuestFedora::Cap::SSHFSClient
       end
 
-      action_hook(:sshfs, :machine_action_provision) do |hook|
-        hook.append(Vagrant::SshFS::Actions::Provision)
+      guest_capability("fedora", "sshfs_install") do
+        require_relative "cap/fedora/sshfs_client"
+        VagrantPlugins::GuestFedora::Cap::SSHFSClient
       end
 
-      action_hook(:sshfs, :machine_action_suspend) do |hook|
-        hook.append(Vagrant::SshFS::Actions::Suspend)
+      guest_capability("debian", "sshfs_installed") do
+        require_relative "cap/debian/sshfs_client"
+        VagrantPlugins::GuestDebian::Cap::SSHFSClient
       end
 
-      action_hook(:sshfs, :machine_action_resume) do |hook|
-        hook.append(Vagrant::SshFS::Actions::Resume)
+      guest_capability("debian", "sshfs_install") do
+        require_relative "cap/debian/sshfs_client"
+        VagrantPlugins::GuestDebian::Cap::SSHFSClient
       end
 
-      action_hook(:sshfs, :machine_action_halt) do |hook|
-        hook.append(Vagrant::SshFS::Actions::Halt)
+      guest_capability("arch", "sshfs_installed") do
+        require_relative "cap/arch/sshfs_client"
+        VagrantPlugins::GuestArch::Cap::SSHFSClient
       end
 
-      action_hook(:sshfs, :machine_action_destroy) do |hook|
-        hook.append(Vagrant::SshFS::Actions::Destroy)
+      guest_capability("arch", "sshfs_install") do
+        require_relative "cap/arch/sshfs_client"
+        VagrantPlugins::GuestArch::Cap::SSHFSClient
       end
 
-      command "sshfs" do
-        Vagrant::SshFS::Command
+      guest_capability("suse", "sshfs_installed") do
+        require_relative "cap/suse/sshfs_client"
+        VagrantPlugins::GuestSUSE::Cap::SSHFSClient
       end
+
+      guest_capability("suse", "sshfs_install") do
+        require_relative "cap/suse/sshfs_client"
+        VagrantPlugins::GuestSUSE::Cap::SSHFSClient
+      end
+
     end
   end
 end