vagrant-reflect 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 27514930e4a083e72bf754603e5cf8b1a4e4edfe
-  data.tar.gz: 143c954865bc3b8d4292eba8fd13e87f8582a70a
+  metadata.gz: e84bae9f41ff115636ac176da7601c803d83389d
+  data.tar.gz: 627b6a9da251a1da3998de39a25b6fd82564b9a2
 SHA512:
-  metadata.gz: 292239d704ae4416df60d289d695456b7d5ae1bf71c743572b78e9a046dabc673d12cf7880443c5a76ea8cfecabb3fb0eb637169d88097f4e56ea951acb5d4a3
-  data.tar.gz: 378cfc2e9047b6fa9f3b2b9378e7d9c42b94ffc34beb2326962a5d4257fb53ded9a87428978f0875dab365c1d0f49059b7a5a6e01bd44172c25dfdc5e7c28f41
+  metadata.gz: 4b852921fb6bce29d04984873f0a543e8982f1ca0fdc4521cbaddd7957c3f5351d55f8515a34e2d44511aeb9ed1262cf3707fbb64fe5d1f291194f21d8bab839
+  data.tar.gz: adb7c4d480eb25fd9288bf9db0b7bb23fe6bb249779262ab3570010b0ec7186ca01d2fa7942225f4e02b84740e77f71b223cb51ccb1e40eb4f152bb762f82f15

data/lib/vagrant-reflect/command/reflect.rb

@@ -1,12 +1,14 @@
 require 'log4r'
 require 'optparse'
 require 'thread'
+require 'date'
 
 require 'vagrant/action/builtin/mixin_synced_folders'
 require 'vagrant/util/busy'
 require 'vagrant/util/platform'
 
-require_relative '../util/syncer'
+require_relative '../util/excludes'
+require_relative '../util/sync'
 
 require 'driskell-listen'
 
@@ -26,21 +28,9 @@ module VagrantReflect
           poll:        false,
           incremental: true
         }
+
         opts = OptionParser.new do |o|
           o.banner = 'Usage: vagrant reflect [vm-name]'
-          o.separator ''
-          o.separator 'Options:'
-          o.separator ''
-
-          o.on('--[no-]poll', 'Force polling filesystem (slow)') do |poll|
-            options[:poll] = poll
-          end
-          o.on(
-            '--[no-]incremental',
-            'Perform incremental copies of changes where possible (fast)'
-          ) do |incremental|
-            options[:incremental] = incremental
-          end
         end
 
         # Parse the options and return if we don't have any target.
@@ -50,28 +40,8 @@ module VagrantReflect
         # Build up the paths that we need to listen to.
         paths = {}
         with_target_vms(argv) do |machine|
-          if machine.provider.capability?(:proxy_machine)
-            proxy = machine.provider.capability(:proxy_machine)
-            if proxy
-              machine.ui.warn(
-                I18n.t(
-                  'vagrant.plugins.vagrant-reflect.rsync_proxy_machine',
-                  name: machine.name.to_s,
-                  provider: machine.provider_name.to_s))
-
-              machine = proxy
-            end
-          end
-
-          cached = synced_folders(machine, cached: true)
-          fresh  = synced_folders(machine)
-          diff   = synced_folders_diff(cached, fresh)
-          unless diff[:added].empty?
-            machine.ui.warn(
-              I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_new_folders'))
-          end
-
-          folders = cached[:rsync]
+          machine = check_proxy(machine)
+          folders = get_folders(machine)
           next if !folders || folders.empty?
 
           folders.each do |id, folder_opts|
@@ -84,7 +54,7 @@ module VagrantReflect
             folder_opts[:exclude] ||= []
             folder_opts[:exclude] << '.vagrant/'
 
-            syncer = Syncer.new(machine, folder_opts)
+            syncer = Util::Sync.new(machine, folder_opts)
 
             machine.ui.info(
               I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_initial'))
@@ -120,7 +90,7 @@ module VagrantReflect
 
           ignores = []
           opts.each do |path_opts|
-            ignores += path_opts[:syncer].excludes_to_regexp
+            ignores += Util::Excludes.convert(path_opts[:opts][:excludes] || [])
             path_opts[:machine].ui.info(
               I18n.t(
                 'vagrant.plugins.vagrant-reflect.rsync_auto_path',
@@ -158,6 +128,33 @@ module VagrantReflect
         0
       end
 
+      def check_proxy(machine)
+        return machine unless machine.provider.capability?(:proxy_machine)
+
+        proxy = machine.provider.capability(:proxy_machine)
+        return machine unless proxy
+
+        machine.ui.warn(
+          I18n.t(
+            'vagrant.plugins.vagrant-reflect.rsync_proxy_machine',
+            name: machine.name.to_s,
+            provider: machine.provider_name.to_s))
+
+        proxy
+      end
+
+      def get_folders(machine)
+        cached = synced_folders(machine, cached: true)
+        fresh  = synced_folders(machine)
+        diff   = synced_folders_diff(cached, fresh)
+        unless diff[:added].empty?
+          machine.ui.warn(
+            I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_new_folders'))
+        end
+
+        cached[:rsync]
+      end
+
       # This is the callback that is called when any changes happen
       def callback(path, opts, options, modified, added, removed)
         @logger.info("File change callback called for #{path}!")
@@ -174,6 +171,7 @@ module VagrantReflect
             send callback, path, path_opts, modified, added, removed
 
             path_opts[:machine].ui.info(
+              get_sync_time +
               I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_synced'))
           rescue Vagrant::Errors::MachineGuestNotReady
             # Error communicating to the machine, probably a reload or
@@ -209,12 +207,15 @@ module VagrantReflect
       end
 
       def sync_incremental(path, path_opts, modified, added, removed)
+        sync_time = get_sync_time
+
         if !modified.empty? || !added.empty?
           # Pass the list of changes to rsync so we quickly synchronise only
           # the changed files instead of the whole folder
           items = strip_paths(path, modified + added)
           path_opts[:syncer].sync_incremental(items) do |item|
             path_opts[:machine].ui.info(
+              sync_time +
               I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_increment_change',
                      path: item))
           end
@@ -226,11 +227,23 @@ module VagrantReflect
         items = strip_paths(path, removed)
         path_opts[:syncer].sync_removals(items) do |item|
           path_opts[:machine].ui.info(
+            sync_time +
             I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_increment_remove',
                    path: item))
         end
       end
 
+      def get_sync_time()
+        # TODO: Hold this configuration per machine when we refactor
+        with_target_vms(nil, single_target: true) do |vm|
+          if vm.config.reflect.show_sync_time == true
+            return '(' + Time.now.strftime("%H:%M:%S") + ') '
+          end
+        end
+
+        ''
+      end
+
       def strip_paths(path, items)
         items.map do |item|
           item[path.length..-1]

data/lib/vagrant-reflect/configuration/reflect.rb

@@ -0,0 +1,25 @@
+module VagrantReflect
+  module Configuration
+    # Configuration object for vagrant-reflect
+    class Reflect < Vagrant.plugin('2', :config)
+      attr_accessor :show_sync_time
+
+      def initialize
+        @show_sync_time = UNSET_VALUE
+      end
+
+      def finalize!
+        @show_sync_time = 0 if @show_sync_time == UNSET_VALUE
+      end
+
+      def validate(_)
+        errors = _detected_errors
+        if show_sync_time != true && show_sync_time != false
+          errors << 'show_sync_time must be TRUE or FALSE'
+        end
+
+        { 'reflect' => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-reflect/patched/subprocess.rb

@@ -1,3 +1,6 @@
+# THIS IS A PATCHED VERSION OF Vagrant::Util::Subprocess THAT FIXES THE ISSUE
+# REPORTED AT: https://github.com/mitchellh/vagrant/pull/7192
+
 require 'thread'
 
 require 'childprocess'

data/lib/vagrant-reflect/plugin.rb

@@ -8,5 +8,10 @@ module VagrantReflect
       require_relative 'command/reflect'
       Command::Reflect
     end
+
+    config 'reflect' do
+      require_relative 'configuration/reflect'
+      Configuration::Reflect
+    end
   end
 end

data/lib/vagrant-reflect/util/excludes.rb

@@ -0,0 +1,53 @@
+module VagrantReflect
+  module Util
+    # This is a helper that builds the required commands and returns them
+    class Excludes
+      class << self
+        PATTERNS = [
+          ['.', '\\.'],
+          ['***', '|||EMPTY|||'],
+          ['**', '|||GLOBAL|||'],
+          ['*', '|||PATH|||'],
+          ['?', '[^/]'],
+          ['|||PATH|||', '[^/]+'],
+          ['|||GLOBAL|||', '.+'],
+          ['|||EMPTY|||', '.*']
+        ].freeze
+
+        # This converts the rsync exclude patterns to regular expressions we can
+        # send to Listen.
+        def convert(excludes)
+          excludes.map(&method(:convert_single))
+        end
+
+        protected
+
+        def convert_single(exclude)
+          start_anchor = false
+
+          if exclude.start_with?('/')
+            start_anchor = true
+            exclude = exclude[1..-1]
+          end
+
+          regexp = start_anchor ? '^' : '(?:^|/)'
+          regexp += perform_substitutions(exclude)
+          regexp += exclude.end_with?('/') ? '' : '(?:/|$)'
+
+          Regexp.new(regexp)
+        end
+
+        def perform_substitutions(exclude)
+          # This is REALLY ghetto, but its a start. We can improve and
+          # keep unit tests passing in the future.
+          # TODO: Escaped wildcards get substituted incorrectly;
+          #       replace with FSM?
+          PATTERNS.each do |pattern|
+            exclude = exclude.gsub(pattern[0], pattern[1])
+          end
+          exclude
+        end
+      end # << self
+    end # ::Excludes
+  end # ::Util
+end # ::VagrantReflect

data/lib/vagrant-reflect/util/reflector.rb

@@ -0,0 +1,82 @@
+require 'driskell-listen'
+require 'json'
+
+# VagrantReflect module
+module VagrantReflect
+  class ShutdownSignal < StandardError; end
+
+  # Reflector instance
+  class Reflector
+    SIGNALS = %w(TERM INT).freeze
+
+    def initialize(path)
+      @path = Pathname.new(File.expand_path(path))
+    end
+
+    def run
+      setup_signals
+      start
+
+      @thread = Thread.current
+      Thread.stop
+    rescue ShutdownSignal
+      stop
+      shutdown_signals
+    end
+
+    protected
+
+    def setup_signals
+      each_signal do
+        raise ShutdownSignal
+      end
+    end
+
+    def shutdown_signals
+      each_signal 'DEFAULT'
+    end
+
+    def each_signal(command = nil, &block)
+      SIGNALS.each do |signal|
+        Signal.trap signal, block_given? ? block : command
+      end
+    end
+
+    def start
+      @listener = Driskell::Listen.to(@path, &method(:callback))
+      @listener.start
+    end
+
+    def stop
+      @listener.stop if @listener.state != :stopped
+    end
+
+    def record
+      @record unless @record.nil?
+
+      # TODO: This is a hack to get at the record data, we need to expose it in
+      # the listen gem
+      backend = @listener.instance_variable_get(:@backend)
+      adapter = backend.instance_variable_get(:@adapter)
+      change = adapter.instance_variable_get(:@snapshots)[@path]
+      @record = change.instance_variable_get(:@record)
+    end
+
+    def callback(modified, added, removed)
+      output = {}
+
+      output[:added] = added.map(&method(:fetch_data))
+      output[:modified] = modified.map(&method(:fetch_data))
+      output[:removed] = removed
+
+      puts JSON.fast_generate(output)
+    end
+
+    def fetch_data(path)
+      rel_path = Pathname.new(path).relative_path_from(@path)
+      data = record.file_data(rel_path)
+      data[:path] = rel_path
+      data
+    end
+  end
+end

data/lib/vagrant-reflect/util/shell.rb

@@ -0,0 +1,136 @@
+module VagrantReflect
+  module Util
+    # This is a helper that builds the required commands and returns them
+    class Shell
+      def initialize(machine, guestpath, hostpath, excludes)
+        @machine = machine
+        @guestpath = guestpath
+        @hostpath = hostpath
+        @excludes = excludes || []
+
+        init_connection_info
+        init_commands
+      end
+
+      attr_reader :rsync_command_inc
+      attr_reader :rsync_command_full
+      attr_reader :rm_command
+      attr_reader :rmdir_command
+
+      protected
+
+      def init_connection_info
+        # Connection information
+        username = @machine.ssh_info[:username]
+        host     = @machine.ssh_info[:host]
+        @remote = "#{username}@#{host}"
+        @target = "#{@remote}:#{@guestpath}"
+      end
+
+      def init_commands
+        @workdir = @machine.env.root_path.to_s
+
+        build_rsh_command
+
+        base = compile_base_rsync
+        build_rsync_command_full base
+        build_rsync_command_inc base
+
+        build_rm_command
+        build_rmdir_command
+      end
+
+      def build_rsh_command
+        proxy_command = []
+        if @machine.ssh_info[:proxy_command]
+          proxy_command += [
+            '-o',
+            "ProxyCommand='#{@machine.ssh_info[:proxy_command]}'"
+          ]
+        end
+
+        @rsh = rsh_command_args(proxy_command).flatten
+      end
+
+      def rsh_command_args(proxy_command)
+        [
+          'ssh',
+          '-p', @machine.ssh_info[:port].to_s,
+          proxy_command,
+          '-o', 'StrictHostKeyChecking=no',
+          '-o', 'IdentitiesOnly=true',
+          '-o', 'UserKnownHostsFile=/dev/null',
+          @machine.ssh_info[:private_key_path].map { |p| ['-i', p] }
+        ]
+      end
+
+      def compile_base_rsync
+        # Get the command-line arguments
+        # TODO: Re-enable customisation of this
+        base_rsync = [
+          'rsync', '--verbose', '--archive', '--delete', '-z', '--links']
+
+        # On Windows, we have to set a default chmod flag to avoid permission
+        # issues
+        add_windows_chmod_args(base_rsync) if Vagrant::Util::Platform.windows?
+
+        add_owner_args(base_rsync)
+
+        base_rsync += ['-e', @rsh.join(' ')]
+
+        @excludes.map { |e| base_rsync += ['--exclude', e] }
+
+        base_rsync
+      end
+
+      def add_windows_chmod_args(base_rsync)
+        return if base_rsync.any? { |arg| arg.start_with?('--chmod=') }
+
+        # Ensures that all non-masked bits get enabled
+        base_rsync << '--chmod=ugo=rwX'
+
+        # Remove the -p option if --archive is enabled (--archive equals
+        # -rlptgoD) otherwise new files will not have the destination-default
+        # permissions
+        return unless base_rsync.include?('--archive') ||
+                      base_rsync.include?('-a')
+
+        base_rsync << '--no-perms'
+      end
+
+      def add_owner_args(base_rsync)
+        # Disable rsync's owner/group preservation (implied by --archive) unless
+        # specifically requested, since we adjust owner/group to match shared
+        # folder setting ourselves.
+        base_rsync << '--no-owner' unless
+          base_rsync.include?('--owner') || base_rsync.include?('-o')
+        base_rsync << '--no-group' unless
+          base_rsync.include?('--group') || base_rsync.include?('-g')
+      end
+
+      def build_rsync_command_full(base_rsync)
+        @rsync_command_full = base_rsync + [
+          @hostpath, @target, { workdir: @workdir }]
+      end
+
+      def build_rsync_command_inc(base_rsync)
+        @rsync_command_inc = base_rsync + [
+          '--files-from=-', @hostpath, @target,
+          { workdir: @workdir, notify: :stdin }]
+      end
+
+      def build_rm_command
+        @rm_command = @rsh + [
+          @remote, 'xargs rm -f', { workdir: @workdir, notify: :stdin }]
+      end
+
+      def build_rmdir_command
+        # Make this command silent
+        # Sometimes we attempt to remove parent folders that aren't empty yet
+        # on the remote because we didn't yet sync across all of the removals
+        @rmdir_command = @rsh + [@remote, 'xargs -n 1 rmdir 2>/dev/null',
+                                 { workdir: @workdir, notify: :stdin }]
+      end
+    end # ::Shell
+  end # ::Util
+end # ::VagrantReflect

data/lib/vagrant-reflect/util/sync.rb

@@ -0,0 +1,146 @@
+require 'vagrant/util/platform'
+
+require_relative '../patched/subprocess'
+require_relative 'shell'
+
+module VagrantReflect
+  module Util
+    # This is a helper that abstracts out the functionality of rsync and rm
+    class Sync
+      def initialize(machine, opts)
+        @machine = machine
+
+        init_paths(opts)
+
+        @shell = Shell.new(@machine, @guestpath, @hostpath, opts[:excludes])
+
+        log_configuration opts[:excludes] || []
+      end
+
+      def sync_incremental(items, &block)
+        send_items_to_command items, @shell.rsync_command_inc, &block
+      end
+
+      def sync_full
+        r = Vagrant::Util::SubprocessPatched.execute(*@shell.rsync_command_full)
+        check_exit @shell.rsync_command_full, r
+      end
+
+      def sync_removals(items, &block)
+        # Look for removed directories and fill in guest paths
+        dirs = prepare_items_for_removal(items)
+
+        send_items_to_command items, @shell.rm_command, &block
+        sync_removals_parents dirs.values unless dirs.empty?
+      end
+
+      def sync_removals_parents(guest_items)
+        send_items_to_command guest_items, @shell.rmdir_command
+      end
+
+      protected
+
+      def log_configuration(excludes)
+        @machine.ui.info(
+          I18n.t(
+            'vagrant.plugins.vagrant-reflect.rsync_folder_configuration',
+            guestpath: @guestpath,
+            hostpath: @hostpath))
+
+        return if excludes.empty?
+
+        @machine.ui.info(
+          I18n.t(
+            'vagrant.plugins.vagrant-reflect.rsync_folder_excludes',
+            excludes: excludes.inspect))
+      end
+
+      def init_paths(opts)
+        # Folder info
+        @guestpath = opts[:guestpath]
+        @hostpath  = opts[:hostpath]
+        @hostpath  = File.expand_path(@hostpath, @machine.env.root_path)
+        @hostpath  = Vagrant::Util::Platform.fs_real_path(@hostpath).to_s
+
+        if Vagrant::Util::Platform.windows?
+          # rsync for Windows expects cygwin style paths, always.
+          @hostpath = Vagrant::Util::Platform.cygwin_path(@hostpath)
+        end
+
+        # Make sure the host path ends with a "/" to avoid creating
+        # a nested directory...
+        @hostpath += '/' unless @hostpath.end_with?('/')
+      end
+
+      def prepare_items_for_removal(items)
+        dirs = {}
+        items.map! do |rel_path|
+          check_for_empty_parents(rel_path, dirs)
+          @guestpath + rel_path
+        end
+        dirs
+      end
+
+      def check_for_empty_parents(rel_path, dirs)
+        parent = rel_path
+        loop do
+          parent = File.dirname(parent)
+          break if parent == '/'
+          next if File.exist?(@hostpath + parent)
+          # Insertion order is maintained so ensure we move repeated paths to
+          # end so they are deleted last
+          dirs.delete parent
+          dirs[parent] = @guestpath + parent
+        end
+      end
+
+      def send_items_to_command(items, command, &block)
+        current = next_item(items, &block)
+        r = Vagrant::Util::SubprocessPatched.execute(*command) do |what, io|
+          next if what != :stdin
+
+          current = process_items(io, items, current, &block)
+        end
+        check_exit command, r
+      end
+
+      def process_items(io, items, current, &block)
+        until current.nil?
+          send_data(io, current)
+          current = next_item(items, &block)
+        end
+
+        # Finished! Close stdin
+        io.close_write
+      rescue IO::WaitWritable, Errno::EINTR
+        # Wait for writable again
+        return current
+      end
+
+      def next_item(items)
+        return nil if items.empty?
+        current = items.shift + "\n"
+        yield current if block_given?
+        current
+      end
+
+      def send_data(io, current)
+        # Handle partial writes
+        n = io.write_nonblock(current)
+        return unless n < current.length
+        current.slice! 0, n
+        throw IO::WaitWritable
+      end
+
+      def check_exit(command, r)
+        return if r.exit_code == 0
+
+        raise Vagrant::Errors::RSyncError,
+              command: command.join(' '),
+              guestpath: @guestpath,
+              hostpath: @hostpath,
+              stderr: r.stderr
+      end
+    end # ::Sync
+  end # ::Util
+end # ::VagrantReflect

data/lib/vagrant-reflect/version.rb

@@ -1,3 +1,3 @@
 module VagrantReflect
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-reflect
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Jason Woods
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-31 00:00:00.000000000 Z
+date: 2016-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: driskell-listen
@@ -39,9 +39,13 @@ extra_rdoc_files: []
 files:
 - lib/vagrant-reflect.rb
 - lib/vagrant-reflect/command/reflect.rb
+- lib/vagrant-reflect/configuration/reflect.rb
 - lib/vagrant-reflect/patched/subprocess.rb
 - lib/vagrant-reflect/plugin.rb
-- lib/vagrant-reflect/util/syncer.rb
+- lib/vagrant-reflect/util/excludes.rb
+- lib/vagrant-reflect/util/reflector.rb
+- lib/vagrant-reflect/util/shell.rb
+- lib/vagrant-reflect/util/sync.rb
 - lib/vagrant-reflect/version.rb
 - templates/locales/en.yml
 homepage: https://github.com/driskell/vagrant-reflect

data/lib/vagrant-reflect/util/syncer.rb

@@ -1,327 +0,0 @@
-require 'vagrant/util/platform'
-
-require_relative '../patched/subprocess'
-
-module VagrantReflect
-  # This is a helper that abstracts out the functionality of rsyncing
-  # folders so that it can be called from anywhere.
-  class Syncer
-    RSYNC_TO_REGEXP_PATTERNS = [
-      ['.', '\\.'],
-      ['***', '|||EMPTY|||'],
-      ['**', '|||GLOBAL|||'],
-      ['*', '|||PATH|||'],
-      ['?', '[^/]'],
-      ['|||PATH|||', '[^/]+'],
-      ['|||GLOBAL|||', '.+'],
-      ['|||EMPTY|||', '.*']
-    ].freeze
-
-    def initialize(machine, opts)
-      @opts = opts
-      @machine = machine
-      @workdir = @machine.env.root_path.to_s
-
-      init_paths
-      init_connection_info
-      init_excludes
-      init_commands
-    end
-
-    def log_configuration
-      @machine.ui.info(
-        I18n.t(
-          'vagrant.plugins.vagrant-reflect.rsync_folder_configuration',
-          guestpath: @guestpath,
-          hostpath: @hostpath))
-
-      return if @excludes.empty?
-
-      @machine.ui.info(
-        I18n.t(
-          'vagrant.plugins.vagrant-reflect.rsync_folder_excludes',
-          excludes: @excludes.inspect))
-    end
-
-    # This converts the rsync exclude patterns to regular expressions we can
-    # send to Listen.
-    def excludes_to_regexp
-      return @regexp if @regexp
-
-      @regexp = @excludes.map(&method(:exclude_to_regex_single))
-    end
-
-    def sync_incremental(items, &block)
-      send_items_to_command items, @rsync_command_inc, &block
-    end
-
-    def sync_full
-      r = Vagrant::Util::SubprocessPatched.execute(*@rsync_command_full)
-      check_exit @rsync_command_full, r
-    end
-
-    def sync_removals(items, &block)
-      # Look for removed directories and fill in guest paths
-      dirs = prepare_items_for_removal(items)
-
-      send_items_to_command items, @rm_command, &block
-      sync_removals_parents dirs.values, &block unless dirs.empty?
-    end
-
-    def sync_removals_parents(guest_items, &block)
-      send_items_to_command guest_items, @rmdir_command, &block
-    end
-
-    protected
-
-    def init_paths
-      # Folder info
-      @guestpath = @opts[:guestpath]
-      @hostpath  = @opts[:hostpath]
-      @hostpath  = File.expand_path(@hostpath, @machine.env.root_path)
-      @hostpath  = Vagrant::Util::Platform.fs_real_path(@hostpath).to_s
-
-      if Vagrant::Util::Platform.windows?
-        # rsync for Windows expects cygwin style paths, always.
-        @hostpath = Vagrant::Util::Platform.cygwin_path(@hostpath)
-      end
-
-      # Make sure the host path ends with a "/" to avoid creating
-      # a nested directory...
-      @hostpath += '/' unless @hostpath.end_with?('/')
-    end
-
-    def init_connection_info
-      # Connection information
-      username = @machine.ssh_info[:username]
-      host     = @machine.ssh_info[:host]
-      @remote = "#{username}@#{host}"
-      @target = "#{@remote}:#{@guestpath}"
-    end
-
-    def init_excludes
-      # Exclude some files by default, and any that might be configured
-      # by the user.
-      @excludes = []
-      @excludes += Array(@opts[:exclude]).map(&:to_s) if @opts[:exclude]
-      @excludes.uniq!
-    end
-
-    def init_commands
-      init_rsh_command
-      init_rsync_command
-      init_rsync_command_full
-      init_rsync_command_inc
-      init_rm_command
-      init_rmdir_command
-    end
-
-    def init_rsh_command
-      proxy_command = []
-      if @machine.ssh_info[:proxy_command]
-        proxy_command += [
-          '-o',
-          "ProxyCommand='#{@machine.ssh_info[:proxy_command]}'"
-        ]
-      end
-
-      @rsh = build_rsh_command(proxy_command).flatten
-    end
-
-    def build_rsh_command(proxy_command)
-      [
-        'ssh',
-        '-p', @machine.ssh_info[:port].to_s,
-        proxy_command,
-        '-o', 'StrictHostKeyChecking=no',
-        '-o', 'IdentitiesOnly=true',
-        '-o', 'UserKnownHostsFile=/dev/null',
-        @machine.ssh_info[:private_key_path].map { |p| ['-i', p] }
-      ]
-    end
-
-    def init_rsync_command
-      # Get the command-line arguments
-      if @opts[:args]
-        @rsync_command = ['rsync'] + Array(@opts[:args]).dup
-      else
-        @rsync_command = [
-          'rsync', '--verbose', '--archive', '--delete', '-z', '--copy-links']
-      end
-
-      # On Windows, we have to set a default chmod flag to avoid permission
-      # issues
-      build_windows_chmod_args if Vagrant::Util::Platform.windows?
-
-      build_owner_args
-
-      @rsync_command += ['-e', @rsh.join(' ')]
-
-      @excludes.map { |e| @rsync_command += ['--exclude', e] }
-    end
-
-    def build_windows_chmod_args
-      return if @rsync_command.any? { |arg| arg.start_with?('--chmod=') }
-
-      # Ensures that all non-masked bits get enabled
-      @rsync_command << '--chmod=ugo=rwX'
-
-      # Remove the -p option if --archive is enabled (--archive equals
-      # -rlptgoD) otherwise new files will not have the destination-default
-      # permissions
-      return unless @rsync_command.include?('--archive') ||
-                    @rsync_command.include?('-a')
-
-      @rsync_command << '--no-perms'
-    end
-
-    def build_owner_args
-      # Disable rsync's owner/group preservation (implied by --archive) unless
-      # specifically requested, since we adjust owner/group to match shared
-      # folder setting ourselves.
-      @rsync_command << '--no-owner' unless
-        @rsync_command.include?('--owner') || @rsync_command.include?('-o')
-      @rsync_command << '--no-group' unless
-        @rsync_command.include?('--group') || @rsync_command.include?('-g')
-    end
-
-    def init_rsync_command_full
-      @rsync_command_full = @rsync_command.dup + [
-        @hostpath,
-        @target,
-        {
-          workdir: @workdir
-        }
-      ]
-    end
-
-    def init_rsync_command_inc
-      @rsync_command_inc = @rsync_command.dup + [
-        '--files-from=-',
-        @hostpath,
-        @target,
-        {
-          workdir: @workdir,
-          notify: :stdin
-        }
-      ]
-    end
-
-    def init_rm_command
-      @rm_command = @rsh.dup + [
-        @remote,
-        'xargs rm -f',
-        {
-          workdir: @workdir,
-          notify: :stdin
-        }
-      ]
-    end
-
-    def init_rmdir_command
-      @rmdir_command = @rsh.dup + [
-        @remote,
-        'xargs rmdir',
-        {
-          workdir: @workdir,
-          notify: :stdin
-        }
-      ]
-    end
-
-    def prepare_items_for_removal(items)
-      dirs = {}
-      items.map! do |rel_path|
-        check_for_empty_parents(rel_path, dirs)
-        @guestpath + rel_path
-      end
-      dirs
-    end
-
-    def check_for_empty_parents(rel_path, dirs)
-      parent = rel_path
-      loop do
-        parent = File.dirname(parent)
-        break if parent == '/'
-        next if File.exist?(@hostpath + parent)
-        # Insertion order is maintained so ensure we move repeated paths to
-        # end so they are deleted last
-        dirs.delete parent
-        dirs[parent] = @guestpath + parent
-      end
-    end
-
-    def send_items_to_command(items, command, &block)
-      current = next_item(items, &block)
-      r = Vagrant::Util::SubprocessPatched.execute(*command) do |what, io|
-        next if what != :stdin
-
-        current = process_items(io, items, current, &block)
-      end
-      check_exit command, r
-    end
-
-    def process_items(io, items, current, &block)
-      until current.nil?
-        send_data(io, current)
-        current = next_item(items, &block)
-      end
-
-      # Finished! Close stdin
-      io.close_write
-    rescue IO::WaitWritable, Errno::EINTR
-      # Wait for writable again
-      return current
-    end
-
-    def next_item(items)
-      return nil if items.empty?
-      current = items.shift + "\n"
-      yield current if block_given?
-      current
-    end
-
-    def send_data(io, current)
-      # Handle partial writes
-      n = io.write_nonblock(current)
-      return unless n < current.length
-      current.slice! 0, n
-      throw IO::WaitWritable
-    end
-
-    def check_exit(command, r)
-      return if r.exit_code == 0
-
-      raise Vagrant::Errors::RSyncError,
-            command: command.join(' '),
-            guestpath: @guestpath,
-            hostpath: @hostpath,
-            stderr: r.stderr
-    end
-
-    def exclude_to_regex_single(exclude)
-      start_anchor = false
-
-      if exclude.start_with?('/')
-        start_anchor = true
-        exclude = exclude[1..-1]
-      end
-
-      regexp = start_anchor ? '^' : '(?:^|/)'
-      regexp += perform_substitutions(exclude)
-      regexp += exclude.end_with?('/') ? '' : '(?:/|$)'
-
-      Regexp.new(regexp)
-    end
-
-    def perform_substitutions(exclude)
-      # This is REALLY ghetto, but its a start. We can improve and
-      # keep unit tests passing in the future.
-      # TODO: Escaped wildcards get substituted incorrectly - replace with FSM?
-      RSYNC_TO_REGEXP_PATTERNS.each do |pattern|
-        exclude = exclude.gsub(pattern[0], pattern[1])
-      end
-      exclude
-    end
-  end
-end