vagrant-reflect 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 60e8d10dfb9b80d4280d579c126cd27ca7fdc7c0
+  data.tar.gz: 24af14e99f05a3fc076016b46289d6b428bee72c
+SHA512:
+  metadata.gz: d6715d8afd918ac9f9d785b7fa4efe8317afabd485f018852685a51a7e08095c59bb4da540bd2fa53fcfceea68c657d63ec647cf6016636a7246c4f37ca088b5
+  data.tar.gz: 89a8795fa57b45c46fd80034a38be6493e40a3eac3446869f9ed457d4ec923e0b8c865f2cbc6fffdf8bf35f6da0b05f8e4338fca3f2883b1f9a0fd4c56e314a3

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

@@ -0,0 +1,285 @@
+require 'log4r'
+require 'optparse'
+require 'thread'
+
+require 'vagrant/action/builtin/mixin_synced_folders'
+require 'vagrant/util/busy'
+require 'vagrant/util/platform'
+
+require_relative '../helper'
+
+require 'driskell-listen'
+
+module VagrantReflect
+  module Command
+    class Reflect < Vagrant.plugin('2', :command)
+      include Vagrant::Action::Builtin::MixinSyncedFolders
+
+      def self.synopsis
+        'a better rsync-auto'
+      end
+
+      def execute
+        @logger = Log4r::Logger.new('vagrant::commands::reflect')
+
+        options = {
+          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.
+        argv = parse_options(opts)
+        return unless argv
+
+        # 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]
+          next if !folders || folders.empty?
+
+          # Get the SSH info for this machine so we can do an initial
+          # sync to the VM.
+          ssh_info = machine.ssh_info
+          if ssh_info
+            machine.ui.info(
+              I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_initial'))
+            folders.each do |_, folder_opts|
+              SyncHelper.sync_single(machine, ssh_info, folder_opts)
+            end
+          end
+
+          folders.each do |id, folder_opts|
+            # If we marked this folder to not auto sync, then
+            # don't do it.
+            next if folder_opts.key?(:auto) && !folder_opts[:auto]
+
+            hostpath = folder_opts[:hostpath]
+            hostpath = File.expand_path(hostpath, machine.env.root_path)
+            paths[hostpath] ||= []
+            paths[hostpath] << {
+              id: id,
+              machine: machine,
+              opts:    folder_opts
+            }
+          end
+        end
+
+        # Exit immediately if there is nothing to watch
+        if paths.empty?
+          @env.ui.info(
+            I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_no_paths'))
+          return 1
+        end
+
+        @logger.info(
+          "Listening via: #{Driskell::Listen::Adapter.select.inspect}")
+
+        # Create a listener for each path so the callback can easily
+        # distinguish which path changed
+        listeners = paths.keys.sort.collect do |path|
+          opts = paths[path]
+          callback = method(:callback).to_proc.curry[path][opts][options]
+
+          ignores = []
+          opts.each do |path_opts|
+            path_opts[:machine].ui.info(
+              I18n.t(
+                'vagrant.plugins.vagrant-reflect.rsync_auto_path',
+                path: path.to_s))
+
+            next unless path_opts[:exclude]
+
+            Array(path_opts[:exclude]).each do |pattern|
+              ignores << SyncHelper.exclude_to_regexp(hostpath, pattern.to_s)
+            end
+          end
+
+          @logger.info("Listening to path: #{path}")
+          @logger.info("Ignoring #{ignores.length} paths:")
+          ignores.each do |ignore|
+            @logger.info("-- #{ignore}")
+          end
+
+          listopts = { ignore: ignores, force_polling: options[:poll] }
+          Driskell::Listen.to(path, listopts, &callback)
+        end
+
+        # Create the callback that lets us know when we've been interrupted
+        queue    = Queue.new
+        callback = lambda do
+          # This needs to execute in another thread because Thread
+          # synchronization can't happen in a trap context.
+          Thread.new { queue << true }
+        end
+
+        # Run the listeners in a busy block so that we can cleanly
+        # exit once we receive an interrupt.
+        Vagrant::Util::Busy.busy(callback) do
+          listeners.each(&:start)
+          queue.pop
+          listeners.each do |listener|
+            listener.stop if listener.state != :stopped
+          end
+        end
+
+        0
+      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}!")
+        @logger.info("  - Modified: #{modified.inspect}")
+        @logger.info("  - Added: #{added.inspect}")
+        @logger.info("  - Removed: #{removed.inspect}")
+
+        # Perform the sync for each machine
+        opts.each do |path_opts|
+          # Reload so we get the latest ID
+          path_opts[:machine].reload
+          if !path_opts[:machine].id || path_opts[:machine].id == ''
+            # Skip since we can't get SSH info without an ID
+            next
+          end
+
+          begin
+            # If we have any removals or have disabled incremental, perform a
+            # single full sync
+            # It's seemingly impossible to ask rsync to only do a deletion
+            if !options[:incremental] || !removed.empty?
+              removed.each do |remove|
+                path_opts[:machine].ui.info(
+                  I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_remove',
+                         path: remove))
+              end
+
+              [modified, added].each do |changes|
+                changes.each do |change|
+                  path_opts[:machine].ui.info(
+                    I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_change',
+                           path: change))
+                end
+              end
+
+              SyncHelper.sync_single(
+                path_opts[:machine],
+                path_opts[:machine].ssh_info,
+                path_opts[:opts]
+              )
+            elsif !modified.empty? || !added.empty?
+              synchronize_changes(path, path_opts, options, [modified, added])
+            end
+
+            path_opts[:machine].ui.info(
+              I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_synced'))
+          rescue Vagrant::Errors::MachineGuestNotReady
+            # Error communicating to the machine, probably a reload or
+            # halt is happening. Just notify the user but don't fail out.
+            path_opts[:machine].ui.error(
+              I18n.t('vagrant.plugins.vagrant-reflect.'\
+                     'rsync_communicator_not_ready_callback'))
+          rescue Vagrant::Errors::VagrantError => e
+            path_opts[:machine].ui.error(e)
+          end
+        end
+      end
+
+      # Helper to pull the next change from a set of changes of the form
+      # [ set1, set2, set3 ]
+      # Sets are removed as they are emptied
+      def next_change(sets, path)
+        line = sets[0].pop
+        sets.shift while !sets.empty? && sets[0].empty?
+        line[path.length..line.length] + "\n"
+      end
+
+      def synchronize_changes(path, path_opts, options, sets)
+        # Grab the first change
+        sets.shift while sets[0].empty?
+        line = false
+
+        # Pass the list of changes to rsync so we quickly synchronise only
+        # the changed files instead of the whole folder
+        SyncHelper.sync_single(
+          path_opts[:machine],
+          path_opts[:machine].ssh_info,
+          path_opts[:opts].merge(from_stdin: true)
+        ) do |what, io|
+          next if what != :stdin
+
+          if line.nil?
+            io.close_write
+            next
+          end
+
+          begin
+            loop do
+              # If we don't have a line, grab one and print it
+              unless line
+                line = next_change(sets, path)
+                path_opts[:machine].ui.info(
+                  I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_increment',
+                         path: line))
+              end
+
+              # Handle partial writes
+              n = io.write_nonblock(line)
+              if n < line.length
+                line = line[n..line.length]
+                break
+              end
+
+              # When we've finished giving rsync the file list, set line to nil
+              # and return - on the next notify we will EOT stdin
+              if sets.empty?
+                line = nil
+                break
+              end
+
+              # Request a new line for next write
+              line = false
+            end
+          rescue IO::WaitWritable, Errno::EINTR
+            # Ignore
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-reflect/helper.rb

@@ -0,0 +1,167 @@
+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 SyncHelper
+    # This converts an rsync exclude pattern to a regular expression
+    # we can send to Listen.
+    def self.exclude_to_regexp(path, exclude)
+      start_anchor = false
+
+      if exclude.start_with?('/')
+        start_anchor = true
+        exclude      = exclude[1..-1]
+      end
+
+      path   = "#{path}/" unless path.end_with?('/')
+      regexp = "^#{Regexp.escape(path)}"
+      regexp += '.*' unless start_anchor
+
+      # This is REALLY ghetto, but its a start. We can improve and
+      # keep unit tests passing in the future.
+      exclude = exclude.gsub('**', '|||GLOBAL|||')
+      exclude = exclude.gsub('*', '|||PATH|||')
+      exclude = exclude.gsub('|||PATH|||', '[^/]*')
+      exclude = exclude.gsub('|||GLOBAL|||', '.*')
+      regexp += exclude
+
+      Regexp.new(regexp)
+    end
+
+    def self.sync_single(machine, ssh_info, opts, &block)
+      # 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?('/')
+
+      # Folder options
+      opts[:owner] ||= ssh_info[:username]
+      opts[:group] ||= ssh_info[:username]
+
+      # Connection information
+      username = ssh_info[:username]
+      host     = ssh_info[:host]
+      proxy_command = ''
+      if ssh_info[:proxy_command]
+        proxy_command = "-o ProxyCommand='#{ssh_info[:proxy_command]}' "
+      end
+
+      rsh = [
+        "ssh -p #{ssh_info[:port]} " +
+          proxy_command +
+          '-o StrictHostKeyChecking=no '\
+          '-o IdentitiesOnly=true '\
+          '-o UserKnownHostsFile=/dev/null',
+        ssh_info[:private_key_path].map { |p| "-i '#{p}'" }
+      ].flatten.join(' ')
+
+      # Exclude some files by default, and any that might be configured
+      # by the user.
+      excludes = ['.vagrant/']
+      excludes += Array(opts[:exclude]).map(&:to_s) if opts[:exclude]
+      excludes.uniq!
+
+      # Get the command-line arguments
+      args = nil
+      args = Array(opts[:args]).dup if opts[:args]
+      args ||= ['--verbose', '--archive', '--delete', '-z', '--copy-links']
+
+      # On Windows, we have to set a default chmod flag to avoid permission
+      # issues
+      if Vagrant::Util::Platform.windows?
+        unless args.any? { |arg| arg.start_with?('--chmod=') }
+          # Ensures that all non-masked bits get enabled
+          args << '--chmod=ugo=rwX'
+
+          # Remove the -p option if --archive is enabled (--archive equals
+          # -rlptgoD) otherwise new files will not have the destination-default
+          # permissions
+          args << '--no-perms' if
+            args.include?('--archive') || args.include?('-a')
+        end
+      end
+
+      # Disable rsync's owner/group preservation (implied by --archive) unless
+      # specifically requested, since we adjust owner/group to match shared
+      # folder setting ourselves.
+      args << '--no-owner' unless
+        args.include?('--owner') || args.include?('-o')
+      args << '--no-group' unless
+        args.include?('--group') || args.include?('-g')
+
+      # Tell local rsync how to invoke remote rsync with sudo
+      if machine.guest.capability?(:rsync_command)
+        args << '--rsync-path' << machine.guest.capability(:rsync_command)
+      end
+
+      args << '--files-from=-' if opts[:from_stdin] && block_given?
+
+      # Build up the actual command to execute
+      command = [
+        'rsync',
+        args,
+        '-e', rsh,
+        excludes.map { |e| ['--exclude', e] },
+        hostpath,
+        "#{username}@#{host}:#{guestpath}"
+      ].flatten
+
+      # The working directory should be the root path
+      command_opts = {}
+      command_opts[:workdir] = machine.env.root_path.to_s
+      command_opts[:notify] = [:stdin] if opts[:from_stdin] && block_given?
+
+      if opts[:from_stdin] && block_given?
+        machine.ui.info(
+          I18n.t(
+            'vagrant.plugins.vagrant-reflect.rsync_folder_changes',
+            guestpath: guestpath,
+            hostpath: hostpath))
+      else
+        machine.ui.info(
+          I18n.t(
+            'vagrant.plugins.vagrant-reflect.rsync_folder',
+            guestpath: guestpath,
+            hostpath: hostpath))
+      end
+      if excludes.length > 1
+        machine.ui.info(
+          I18n.t(
+            'vagrant.plugins.vagrant-reflect.rsync_folder_excludes',
+            excludes: excludes.inspect))
+      end
+
+      # If we have tasks to do before rsyncing, do those.
+      if machine.guest.capability?(:rsync_pre)
+        machine.guest.capability(:rsync_pre, opts)
+      end
+
+      r = Vagrant::Util::SubprocessPatched.execute(*(command + [command_opts]), &block)
+      if r.exit_code != 0
+        raise Vagrant::Errors::RSyncError,
+              command: command.join(' '),
+              guestpath: guestpath,
+              hostpath: hostpath,
+              stderr: r.stderr
+      end
+
+      # If we have tasks to do after rsyncing, do those.
+      if machine.guest.capability?(:rsync_post)
+        machine.guest.capability(:rsync_post, opts)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,316 @@
+require 'thread'
+
+require 'childprocess'
+require 'log4r'
+
+require 'vagrant/util/io'
+require 'vagrant/util/platform'
+require 'vagrant/util/safe_chdir'
+require 'vagrant/util/which'
+
+module Vagrant
+  module Util
+    # Execute a command in a subprocess, gathering the results and
+    # exit status.
+    #
+    # This class also allows you to read the data as it is outputted
+    # from the subprocess in real time, by simply passing a block to
+    # the execute method.
+    class SubprocessPatched
+      # Convenience method for executing a method.
+      def self.execute(*command, &block)
+        new(*command).execute(&block)
+      end
+
+      def initialize(*command)
+        @options = command.last.is_a?(Hash) ? command.pop : {}
+        @command = command.dup
+        @command = @command.map { |s| s.encode(Encoding.default_external) }
+        @command[0] = Which.which(@command[0]) if !File.file?(@command[0])
+        if !@command[0]
+          raise Errors::CommandUnavailableWindows, file: command[0] if Platform.windows?
+          raise Errors::CommandUnavailable, file: command[0]
+        end
+
+        @logger  = Log4r::Logger.new("vagrant::util::subprocess")
+      end
+
+      def execute
+        # Get the timeout, if we have one
+        timeout = @options[:timeout]
+
+        # Get the working directory
+        workdir = @options[:workdir] || Dir.pwd
+
+        # Get what we're interested in being notified about
+        notify  = @options[:notify] || []
+        notify  = [notify] if !notify.is_a?(Array)
+        if notify.empty? && block_given?
+          # If a block is given, subscribers must be given, otherwise the
+          # block is never called. This is usually NOT what you want, so this
+          # is an error.
+          message = "A list of notify subscriptions must be given if a block is given"
+          raise ArgumentError, message
+        end
+
+        # Let's get some more useful booleans that we access a lot so
+        # we're not constantly calling an `include` check
+        notify_table = {}
+        notify_table[:stderr] = notify.include?(:stderr)
+        notify_table[:stdout] = notify.include?(:stdout)
+        notify_stdin  = notify.include?(:stdin)
+
+        # Build the ChildProcess
+        @logger.info("Starting process: #{@command.inspect}")
+        process = ChildProcess.build(*@command)
+
+        # Create the pipes so we can read the output in real time as
+        # we execute the command.
+        stdout, stdout_writer = ::IO.pipe
+        stderr, stderr_writer = ::IO.pipe
+        process.io.stdout = stdout_writer
+        process.io.stderr = stderr_writer
+        process.duplex = true
+
+        # Special installer-related things
+        if Vagrant.in_installer?
+          installer_dir = ENV["VAGRANT_INSTALLER_EMBEDDED_DIR"].to_s.downcase
+
+          # If we're in an installer on Mac and we're executing a command
+          # in the installer context, then force DYLD_LIBRARY_PATH to look
+          # at our libs first.
+          if Platform.darwin?
+            if @command[0].downcase.include?(installer_dir)
+              @logger.info("Command in the installer. Specifying DYLD_LIBRARY_PATH...")
+              process.environment["DYLD_LIBRARY_PATH"] =
+                "#{installer_dir}/lib:#{ENV["DYLD_LIBRARY_PATH"]}"
+            else
+              @logger.debug("Command not in installer, not touching env vars.")
+            end
+
+            if File.setuid?(@command[0]) || File.setgid?(@command[0])
+              @logger.info("Command is setuid/setgid, clearing DYLD_LIBRARY_PATH")
+              process.environment["DYLD_LIBRARY_PATH"] = ""
+            end
+          end
+
+          # If the command that is being run is not inside the installer, reset
+          # the original environment - this is required for shelling out to
+          # other subprocesses that depend on environment variables (like Ruby
+          # and $GEM_PATH for example)
+          internal = [installer_dir, Vagrant.user_data_path.to_s.downcase].
+            any? { |path| @command[0].downcase.include?(path) }
+          if !internal
+            @logger.info("Command not in installer, restoring original environment...")
+            jailbreak(process.environment)
+          end
+        else
+          @logger.info("Vagrant not running in installer, restoring original environment...")
+          jailbreak(process.environment)
+        end
+
+        # Set the environment on the process if we must
+        if @options[:env]
+          @options[:env].each do |k, v|
+            process.environment[k] = v
+          end
+        end
+
+        # Start the process
+        begin
+          SafeChdir.safe_chdir(workdir) do
+            process.start
+          end
+        rescue ChildProcess::LaunchError => ex
+          # Raise our own version of the error so that users of the class
+          # don't need to be aware of ChildProcess
+          raise LaunchError.new(ex.message)
+        end
+
+        # Make sure the stdin does not buffer
+        process.io.stdin.sync = true
+
+        if RUBY_PLATFORM != "java"
+          # On Java, we have to close after. See down the method...
+          # Otherwise, we close the writers right here, since we're
+          # not on the writing side.
+          stdout_writer.close
+          stderr_writer.close
+        end
+
+        # Create a dictionary to store all the output we see.
+        io_data = { stdout: "", stderr: "" }
+
+        # Record the start time for timeout purposes
+        start_time = Time.now.to_i
+
+        @logger.debug("Selecting on IO")
+        while true
+          # PATCH BEGINS HERE TO FIX STDIN CLOSURE
+          writers = notify_stdin && !process.io.stdin.closed? ? [process.io.stdin] : []
+          # PATCH END
+          results = ::IO.select([stdout, stderr], writers, nil, 0.1)
+          results ||= []
+          readers = results[0]
+          writers = results[1]
+
+          # Check if we have exceeded our timeout
+          raise TimeoutExceeded, process.pid if timeout && (Time.now.to_i - start_time) > timeout
+
+          # Check the readers to see if they're ready
+          if readers && !readers.empty?
+            readers.each do |r|
+              # Read from the IO object
+              data = IO.read_until_block(r)
+
+              # We don't need to do anything if the data is empty
+              next if data.empty?
+
+              io_name = r == stdout ? :stdout : :stderr
+              @logger.debug("#{io_name}: #{data.chomp}")
+
+              io_data[io_name] += data
+              yield io_name, data if block_given? && notify_table[io_name]
+            end
+          end
+
+          # Break out if the process exited. We have to do this before
+          # attempting to write to stdin otherwise we'll get a broken pipe
+          # error.
+          break if process.exited?
+
+          # Check the writers to see if they're ready, and notify any listeners
+          if writers && !writers.empty? && block_given?
+            yield :stdin, process.io.stdin
+          end
+        end
+
+        # Wait for the process to end.
+        begin
+          remaining = (timeout || 32000) - (Time.now.to_i - start_time)
+          remaining = 0 if remaining < 0
+          @logger.debug("Waiting for process to exit. Remaining to timeout: #{remaining}")
+
+          process.poll_for_exit(remaining)
+        rescue ChildProcess::TimeoutError
+          raise TimeoutExceeded, process.pid
+        end
+
+        @logger.debug("Exit status: #{process.exit_code}")
+
+        # Read the final output data, since it is possible we missed a small
+        # amount of text between the time we last read data and when the
+        # process exited.
+        [stdout, stderr].each do |io|
+          # Read the extra data, ignoring if there isn't any
+          extra_data = IO.read_until_block(io)
+          next if extra_data == ""
+
+          # Log it out and accumulate
+          io_name = io == stdout ? :stdout : :stderr
+          io_data[io_name] += extra_data
+          @logger.debug("#{io_name}: #{extra_data.chomp}")
+
+          # Yield to any listeners any remaining data
+          yield io_name, extra_data if block_given? && notify_table[io_name]
+        end
+
+        if RUBY_PLATFORM == "java"
+          # On JRuby, we need to close the writers after the process,
+          # for some reason. See GH-711.
+          stdout_writer.close
+          stderr_writer.close
+        end
+
+        # Return an exit status container
+        return Result.new(process.exit_code, io_data[:stdout], io_data[:stderr])
+      ensure
+        if process && process.alive?
+          # Make sure no matter what happens, the process exits
+          process.stop(2)
+        end
+      end
+
+      protected
+
+      # An error which raises when a process fails to start
+      class LaunchError < StandardError; end
+
+      # An error which occurs when the process doesn't end within
+      # the given timeout.
+      class TimeoutExceeded < StandardError
+        attr_reader :pid
+
+        def initialize(pid)
+          super()
+          @pid = pid
+        end
+      end
+
+      # Container class to store the results of executing a subprocess.
+      class Result
+        attr_reader :exit_code
+        attr_reader :stdout
+        attr_reader :stderr
+
+        def initialize(exit_code, stdout, stderr)
+          @exit_code = exit_code
+          @stdout    = stdout
+          @stderr    = stderr
+        end
+      end
+
+      private
+
+      # This is, quite possibly, the saddest function in all of Vagrant.
+      #
+      # If a user is running Vagrant via Bundler (but not via the official
+      # installer), we want to reset to the "original" environment so that when
+      # shelling out to other Ruby processes (specifically), the original
+      # environment is restored. This is super important for things like
+      # rbenv and chruby, who rely on environment variables to locate gems, but
+      # Bundler stomps on those environment variables like an angry T-Rex after
+      # watching Jurassic Park 2 and realizing they replaced you with CGI.
+      #
+      # If a user is running in Vagrant via the official installer, BUT trying
+      # to execute a subprocess *outside* of the installer, we want to reset to
+      # the "original" environment. In this case, the Vagrant installer actually
+      # knows what the original environment was and replaces it completely.
+      #
+      # Finally, we reset any Bundler-specific environment variables, since the
+      # subprocess being called could, itself, be Bundler. And Bundler does not
+      # behave very nicely in these circumstances.
+      #
+      # This function was added in Vagrant 1.7.3, but there is a failsafe
+      # because the author doesn't trust himself that this functionality won't
+      # break existing assumptions, so users can specify
+      # `VAGRANT_SKIP_SUBPROCESS_JAILBREAK` and none of the above will happen.
+      #
+      # This function modifies the given hash in place!
+      #
+      # @return [nil]
+      def jailbreak(env = {})
+        return if ENV.key?("VAGRANT_SKIP_SUBPROCESS_JAILBREAK")
+
+        env.replace(::Bundler::ORIGINAL_ENV) if defined?(::Bundler::ORIGINAL_ENV)
+        env.merge!(Vagrant.original_env)
+
+        # Bundler does this, so I guess we should as well, since I think it
+        # other subprocesses that use Bundler will reload it
+        env["MANPATH"] = ENV["BUNDLE_ORIG_MANPATH"]
+
+        # Replace all current environment BUNDLE_ variables to nil
+        ENV.each do |k,_|
+          env[k] = nil if k[0,7] == "BUNDLE_"
+        end
+
+        # If RUBYOPT was set, unset it with Bundler
+        if ENV.key?("RUBYOPT")
+          env["RUBYOPT"] = ENV["RUBYOPT"].sub("-rbundler/setup", "")
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/vagrant-reflect/plugin.rb

@@ -0,0 +1,12 @@
+# Vagrant Reflect plugin
+module VagrantReflect
+  # A Vagrant Plugin
+  class Plugin < Vagrant.plugin('2')
+    name 'Vagrant Reflect'
+
+    command 'reflect' do
+      require_relative 'command/reflect'
+      Command::Reflect
+    end
+  end
+end

data/lib/vagrant-reflect/version.rb

@@ -0,0 +1,3 @@
+module VagrantReflect
+  VERSION = '0.1.0'
+end

data/lib/vagrant-reflect.rb

@@ -0,0 +1,7 @@
+require 'vagrant'
+
+I18n.load_path << File.join(
+  File.dirname(File.dirname(__FILE__)), 'templates/locales/en.yml')
+
+require 'vagrant-reflect/plugin'
+require 'vagrant-reflect/version'

data/templates/locales/en.yml

@@ -0,0 +1,37 @@
+en:
+  vagrant:
+    plugins:
+      vagrant-reflect:
+        rsync_auto_initial: |-
+          Doing an initial rsync...
+        rsync_auto_new_folders: |-
+          New synced folders were added to the Vagrantfile since running
+          `vagrant reload`. If these new synced folders are backed by rsync,
+          they won't be automatically synced until a `vagrant reload` is run.
+        rsync_auto_no_paths: |-
+          There are no paths to watch! This is either because you have no
+          synced folders using rsync, or any rsync synced folders you have
+          have specified `rsync_auto` to be false.
+        rsync_auto_path: |-
+          Watching: %{path}
+        rsync_auto_increment: |-
+          Sending change: %{path}
+        rsync_auto_change: |-
+          Processing change: %{path}
+        rsync_auto_remove: |-
+          Processing removal: %{path}
+        rsync_auto_synced: |-
+          Synchronization completed
+        rsync_communicator_not_ready_callback: |-
+          Failed to connect to remote machine. This is usually caused by the
+          machine rebooting or being halted. Please make sure the machine is
+          running, and modify a file to try again.
+        rsync_folder: |-
+          Rsyncing folder: %{hostpath} => %{guestpath}
+        rsync_folder_changes: |-
+          Rsyncing changes only: %{hostpath} => %{guestpath}
+        rsync_folder_excludes: "  - Exclude: %{excludes}"
+        rsync_proxy_machine: |-
+          The provider ('%{provider}') for the machine '%{name}' is
+          using a proxy machine. RSync will sync to this proxy
+          instead of directly to the environment itself.

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-reflect
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jason Woods
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: driskell-listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.6.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.6.10
+description: Vagrant Reflect
+email:
+- devel@jasonwoods.me.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/vagrant-reflect.rb
+- lib/vagrant-reflect/command/reflect.rb
+- lib/vagrant-reflect/helper.rb
+- lib/vagrant-reflect/patched/subprocess.rb
+- lib/vagrant-reflect/plugin.rb
+- lib/vagrant-reflect/version.rb
+- templates/locales/en.yml
+homepage: https://github.com/driskell/vagrant-reflect
+licenses:
+- Apache
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: nowarning
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: A better vagrant rsync-auto
+test_files: []
+has_rdoc: